home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / CPU Sources / cpu5.c < prev    next >
C/C++ Source or Header  |  1996-02-13  |  228KB  |  8,137 lines
  1. #include "config.h"
  2. #include "amiga.h"
  3. #include "options.h"
  4. #include <stdlib.h>
  5. #include "memory.h"
  6. #include "custom.h"
  7. #include "newcpu.h"
  8. #include "cputbl.h"
  9. void op_5000(UWORD opcode)
  10. {
  11.     ULONG srcreg = 8;
  12.     ULONG dstreg = (opcode & 7) >> 0;
  13. {{    ULONG src = srcreg;
  14. {    BYTE dst = regs.d[dstreg];
  15. {    ULONG newv = dst + src;
  16. {    bool flgs = ((BYTE)(src)) < 0;
  17.     bool flgo = ((BYTE)(dst)) < 0;
  18.     bool flgn = ((BYTE)(newv)) < 0;
  19.     regs.z = ((BYTE)(newv)) == 0;
  20.     regs.v = (flgs == flgo) && (flgn != flgo);
  21.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  22.     regs.n = flgn != 0;
  23.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  24. }}}}}}
  25. void op_5010(UWORD opcode)
  26. {
  27.     ULONG srcreg = 8;
  28.     ULONG dstreg = (opcode & 7) >> 0;
  29. {{    ULONG src = srcreg;
  30. {    CPTR dsta = regs.a[dstreg];
  31.     BYTE dst = get_byte(dsta);
  32. {    ULONG newv = dst + src;
  33. {    bool flgs = ((BYTE)(src)) < 0;
  34.     bool flgo = ((BYTE)(dst)) < 0;
  35.     bool flgn = ((BYTE)(newv)) < 0;
  36.     regs.z = ((BYTE)(newv)) == 0;
  37.     regs.v = (flgs == flgo) && (flgn != flgo);
  38.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  39.     regs.n = flgn != 0;
  40.     put_byte(dsta,newv);
  41. }}}}}}
  42. void op_5018(UWORD opcode)
  43. {
  44.     ULONG srcreg = 8;
  45.     ULONG dstreg = (opcode & 7) >> 0;
  46. {{    ULONG src = srcreg;
  47. {    CPTR dsta = regs.a[dstreg];
  48.     BYTE dst = get_byte(dsta);
  49. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  50. {    ULONG newv = dst + src;
  51. {    bool flgs = ((BYTE)(src)) < 0;
  52.     bool flgo = ((BYTE)(dst)) < 0;
  53.     bool flgn = ((BYTE)(newv)) < 0;
  54.     regs.z = ((BYTE)(newv)) == 0;
  55.     regs.v = (flgs == flgo) && (flgn != flgo);
  56.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  57.     regs.n = flgn != 0;
  58.     put_byte(dsta,newv);
  59. }}}}}}}
  60. void op_5020(UWORD opcode)
  61. {
  62.     ULONG srcreg = 8;
  63.     ULONG dstreg = (opcode & 7) >> 0;
  64. {{    ULONG src = srcreg;
  65. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  66. {    CPTR dsta = regs.a[dstreg];
  67.     BYTE dst = get_byte(dsta);
  68. {    ULONG newv = dst + src;
  69. {    bool flgs = ((BYTE)(src)) < 0;
  70.     bool flgo = ((BYTE)(dst)) < 0;
  71.     bool flgn = ((BYTE)(newv)) < 0;
  72.     regs.z = ((BYTE)(newv)) == 0;
  73.     regs.v = (flgs == flgo) && (flgn != flgo);
  74.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  75.     regs.n = flgn != 0;
  76.     put_byte(dsta,newv);
  77. }}}}}}}
  78. void op_5028(UWORD opcode)
  79. {
  80.     ULONG srcreg = 8;
  81.     ULONG dstreg = (opcode & 7) >> 0;
  82. {{    ULONG src = srcreg;
  83. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  84.     BYTE dst = get_byte(dsta);
  85. {    ULONG newv = dst + src;
  86. {    bool flgs = ((BYTE)(src)) < 0;
  87.     bool flgo = ((BYTE)(dst)) < 0;
  88.     bool flgn = ((BYTE)(newv)) < 0;
  89.     regs.z = ((BYTE)(newv)) == 0;
  90.     regs.v = (flgs == flgo) && (flgn != flgo);
  91.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  92.     regs.n = flgn != 0;
  93.     put_byte(dsta,newv);
  94. }}}}}}
  95. void op_5030(UWORD opcode)
  96. {
  97.     ULONG srcreg = 8;
  98.     ULONG dstreg = (opcode & 7) >> 0;
  99. {{    ULONG src = srcreg;
  100. {    CPTR dsta = regs.a[dstreg];
  101.     UWORD dstdp = nextiword();
  102.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  103. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  104.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  105.     dsta += dstdpr;
  106. {    BYTE dst = get_byte(dsta);
  107. {    ULONG newv = dst + src;
  108. {    bool flgs = ((BYTE)(src)) < 0;
  109.     bool flgo = ((BYTE)(dst)) < 0;
  110.     bool flgn = ((BYTE)(newv)) < 0;
  111.     regs.z = ((BYTE)(newv)) == 0;
  112.     regs.v = (flgs == flgo) && (flgn != flgo);
  113.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  114.     regs.n = flgn != 0;
  115.     put_byte(dsta,newv);
  116. }}}}}}}}
  117. void op_5038(UWORD opcode)
  118. {
  119.     ULONG srcreg = 8;
  120. {{    ULONG src = srcreg;
  121. {    CPTR dsta = (LONG)(WORD)nextiword();
  122.     BYTE dst = get_byte(dsta);
  123. {    ULONG newv = dst + src;
  124. {    bool flgs = ((BYTE)(src)) < 0;
  125.     bool flgo = ((BYTE)(dst)) < 0;
  126.     bool flgn = ((BYTE)(newv)) < 0;
  127.     regs.z = ((BYTE)(newv)) == 0;
  128.     regs.v = (flgs == flgo) && (flgn != flgo);
  129.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  130.     regs.n = flgn != 0;
  131.     put_byte(dsta,newv);
  132. }}}}}}
  133. void op_5039(UWORD opcode)
  134. {
  135.     ULONG srcreg = 8;
  136. {{    ULONG src = srcreg;
  137. {    CPTR dsta = nextilong();
  138.     BYTE dst = get_byte(dsta);
  139. {    ULONG newv = dst + src;
  140. {    bool flgs = ((BYTE)(src)) < 0;
  141.     bool flgo = ((BYTE)(dst)) < 0;
  142.     bool flgn = ((BYTE)(newv)) < 0;
  143.     regs.z = ((BYTE)(newv)) == 0;
  144.     regs.v = (flgs == flgo) && (flgn != flgo);
  145.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  146.     regs.n = flgn != 0;
  147.     put_byte(dsta,newv);
  148. }}}}}}
  149. void op_5040(UWORD opcode)
  150. {
  151.     ULONG srcreg = 8;
  152.     ULONG dstreg = (opcode & 7) >> 0;
  153. {{    ULONG src = srcreg;
  154. {    WORD dst = regs.d[dstreg];
  155. {    ULONG newv = dst + src;
  156. {    bool flgs = ((WORD)(src)) < 0;
  157.     bool flgo = ((WORD)(dst)) < 0;
  158.     bool flgn = ((WORD)(newv)) < 0;
  159.     regs.z = ((WORD)(newv)) == 0;
  160.     regs.v = (flgs == flgo) && (flgn != flgo);
  161.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  162.     regs.n = flgn != 0;
  163.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  164. }}}}}}
  165. void op_5048(UWORD opcode)
  166. {
  167.     ULONG srcreg = 8;
  168.     ULONG dstreg = (opcode & 7) >> 0;
  169. {{    ULONG src = srcreg;
  170. {    LONG dst = regs.a[dstreg];
  171. {    ULONG newv = dst + src;
  172.     regs.a[dstreg] = (newv);
  173. }}}}}
  174. void op_5050(UWORD opcode)
  175. {
  176.     ULONG srcreg = 8;
  177.     ULONG dstreg = (opcode & 7) >> 0;
  178. {{    ULONG src = srcreg;
  179. {    CPTR dsta = regs.a[dstreg];
  180.     WORD dst = get_word(dsta);
  181. {    ULONG newv = dst + src;
  182. {    bool flgs = ((WORD)(src)) < 0;
  183.     bool flgo = ((WORD)(dst)) < 0;
  184.     bool flgn = ((WORD)(newv)) < 0;
  185.     regs.z = ((WORD)(newv)) == 0;
  186.     regs.v = (flgs == flgo) && (flgn != flgo);
  187.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  188.     regs.n = flgn != 0;
  189.     put_word(dsta,newv);
  190. }}}}}}
  191. void op_5058(UWORD opcode)
  192. {
  193.     ULONG srcreg = 8;
  194.     ULONG dstreg = (opcode & 7) >> 0;
  195. {{    ULONG src = srcreg;
  196. {    CPTR dsta = regs.a[dstreg];
  197.     WORD dst = get_word(dsta);
  198. {    regs.a[dstreg] += 2;
  199. {    ULONG newv = dst + src;
  200. {    bool flgs = ((WORD)(src)) < 0;
  201.     bool flgo = ((WORD)(dst)) < 0;
  202.     bool flgn = ((WORD)(newv)) < 0;
  203.     regs.z = ((WORD)(newv)) == 0;
  204.     regs.v = (flgs == flgo) && (flgn != flgo);
  205.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  206.     regs.n = flgn != 0;
  207.     put_word(dsta,newv);
  208. }}}}}}}
  209. void op_5060(UWORD opcode)
  210. {
  211.     ULONG srcreg = 8;
  212.     ULONG dstreg = (opcode & 7) >> 0;
  213. {{    ULONG src = srcreg;
  214. {    regs.a[dstreg] -= 2;
  215. {    CPTR dsta = regs.a[dstreg];
  216.     WORD dst = get_word(dsta);
  217. {    ULONG newv = dst + src;
  218. {    bool flgs = ((WORD)(src)) < 0;
  219.     bool flgo = ((WORD)(dst)) < 0;
  220.     bool flgn = ((WORD)(newv)) < 0;
  221.     regs.z = ((WORD)(newv)) == 0;
  222.     regs.v = (flgs == flgo) && (flgn != flgo);
  223.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  224.     regs.n = flgn != 0;
  225.     put_word(dsta,newv);
  226. }}}}}}}
  227. void op_5068(UWORD opcode)
  228. {
  229.     ULONG srcreg = 8;
  230.     ULONG dstreg = (opcode & 7) >> 0;
  231. {{    ULONG src = srcreg;
  232. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  233.     WORD dst = get_word(dsta);
  234. {    ULONG newv = dst + src;
  235. {    bool flgs = ((WORD)(src)) < 0;
  236.     bool flgo = ((WORD)(dst)) < 0;
  237.     bool flgn = ((WORD)(newv)) < 0;
  238.     regs.z = ((WORD)(newv)) == 0;
  239.     regs.v = (flgs == flgo) && (flgn != flgo);
  240.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  241.     regs.n = flgn != 0;
  242.     put_word(dsta,newv);
  243. }}}}}}
  244. void op_5070(UWORD opcode)
  245. {
  246.     ULONG srcreg = 8;
  247.     ULONG dstreg = (opcode & 7) >> 0;
  248. {{    ULONG src = srcreg;
  249. {    CPTR dsta = regs.a[dstreg];
  250.     UWORD dstdp = nextiword();
  251.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  252. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  253.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  254.     dsta += dstdpr;
  255. {    WORD dst = get_word(dsta);
  256. {    ULONG newv = dst + src;
  257. {    bool flgs = ((WORD)(src)) < 0;
  258.     bool flgo = ((WORD)(dst)) < 0;
  259.     bool flgn = ((WORD)(newv)) < 0;
  260.     regs.z = ((WORD)(newv)) == 0;
  261.     regs.v = (flgs == flgo) && (flgn != flgo);
  262.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  263.     regs.n = flgn != 0;
  264.     put_word(dsta,newv);
  265. }}}}}}}}
  266. void op_5078(UWORD opcode)
  267. {
  268.     ULONG srcreg = 8;
  269. {{    ULONG src = srcreg;
  270. {    CPTR dsta = (LONG)(WORD)nextiword();
  271.     WORD dst = get_word(dsta);
  272. {    ULONG newv = dst + src;
  273. {    bool flgs = ((WORD)(src)) < 0;
  274.     bool flgo = ((WORD)(dst)) < 0;
  275.     bool flgn = ((WORD)(newv)) < 0;
  276.     regs.z = ((WORD)(newv)) == 0;
  277.     regs.v = (flgs == flgo) && (flgn != flgo);
  278.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  279.     regs.n = flgn != 0;
  280.     put_word(dsta,newv);
  281. }}}}}}
  282. void op_5079(UWORD opcode)
  283. {
  284.     ULONG srcreg = 8;
  285. {{    ULONG src = srcreg;
  286. {    CPTR dsta = nextilong();
  287.     WORD dst = get_word(dsta);
  288. {    ULONG newv = dst + src;
  289. {    bool flgs = ((WORD)(src)) < 0;
  290.     bool flgo = ((WORD)(dst)) < 0;
  291.     bool flgn = ((WORD)(newv)) < 0;
  292.     regs.z = ((WORD)(newv)) == 0;
  293.     regs.v = (flgs == flgo) && (flgn != flgo);
  294.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  295.     regs.n = flgn != 0;
  296.     put_word(dsta,newv);
  297. }}}}}}
  298. void op_5080(UWORD opcode)
  299. {
  300.     ULONG srcreg = 8;
  301.     ULONG dstreg = (opcode & 7) >> 0;
  302. {{    ULONG src = srcreg;
  303. {    LONG dst = regs.d[dstreg];
  304. {    ULONG newv = dst + src;
  305. {    bool flgs = ((LONG)(src)) < 0;
  306.     bool flgo = ((LONG)(dst)) < 0;
  307.     bool flgn = ((LONG)(newv)) < 0;
  308.     regs.z = ((LONG)(newv)) == 0;
  309.     regs.v = (flgs == flgo) && (flgn != flgo);
  310.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  311.     regs.n = flgn != 0;
  312.     regs.d[dstreg] = (newv);
  313. }}}}}}
  314. void op_5088(UWORD opcode)
  315. {
  316.     ULONG srcreg = 8;
  317.     ULONG dstreg = (opcode & 7) >> 0;
  318. {{    ULONG src = srcreg;
  319. {    LONG dst = regs.a[dstreg];
  320. {    ULONG newv = dst + src;
  321.     regs.a[dstreg] = (newv);
  322. }}}}}
  323. void op_5090(UWORD opcode)
  324. {
  325.     ULONG srcreg = 8;
  326.     ULONG dstreg = (opcode & 7) >> 0;
  327. {{    ULONG src = srcreg;
  328. {    CPTR dsta = regs.a[dstreg];
  329.     LONG dst = get_long(dsta);
  330. {    ULONG newv = dst + src;
  331. {    bool flgs = ((LONG)(src)) < 0;
  332.     bool flgo = ((LONG)(dst)) < 0;
  333.     bool flgn = ((LONG)(newv)) < 0;
  334.     regs.z = ((LONG)(newv)) == 0;
  335.     regs.v = (flgs == flgo) && (flgn != flgo);
  336.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  337.     regs.n = flgn != 0;
  338.     put_long(dsta,newv);
  339. }}}}}}
  340. void op_5098(UWORD opcode)
  341. {
  342.     ULONG srcreg = 8;
  343.     ULONG dstreg = (opcode & 7) >> 0;
  344. {{    ULONG src = srcreg;
  345. {    CPTR dsta = regs.a[dstreg];
  346.     LONG dst = get_long(dsta);
  347. {    regs.a[dstreg] += 4;
  348. {    ULONG newv = dst + src;
  349. {    bool flgs = ((LONG)(src)) < 0;
  350.     bool flgo = ((LONG)(dst)) < 0;
  351.     bool flgn = ((LONG)(newv)) < 0;
  352.     regs.z = ((LONG)(newv)) == 0;
  353.     regs.v = (flgs == flgo) && (flgn != flgo);
  354.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  355.     regs.n = flgn != 0;
  356.     put_long(dsta,newv);
  357. }}}}}}}
  358. void op_50a0(UWORD opcode)
  359. {
  360.     ULONG srcreg = 8;
  361.     ULONG dstreg = (opcode & 7) >> 0;
  362. {{    ULONG src = srcreg;
  363. {    regs.a[dstreg] -= 4;
  364. {    CPTR dsta = regs.a[dstreg];
  365.     LONG dst = get_long(dsta);
  366. {    ULONG newv = dst + src;
  367. {    bool flgs = ((LONG)(src)) < 0;
  368.     bool flgo = ((LONG)(dst)) < 0;
  369.     bool flgn = ((LONG)(newv)) < 0;
  370.     regs.z = ((LONG)(newv)) == 0;
  371.     regs.v = (flgs == flgo) && (flgn != flgo);
  372.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  373.     regs.n = flgn != 0;
  374.     put_long(dsta,newv);
  375. }}}}}}}
  376. void op_50a8(UWORD opcode)
  377. {
  378.     ULONG srcreg = 8;
  379.     ULONG dstreg = (opcode & 7) >> 0;
  380. {{    ULONG src = srcreg;
  381. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  382.     LONG dst = get_long(dsta);
  383. {    ULONG newv = dst + src;
  384. {    bool flgs = ((LONG)(src)) < 0;
  385.     bool flgo = ((LONG)(dst)) < 0;
  386.     bool flgn = ((LONG)(newv)) < 0;
  387.     regs.z = ((LONG)(newv)) == 0;
  388.     regs.v = (flgs == flgo) && (flgn != flgo);
  389.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  390.     regs.n = flgn != 0;
  391.     put_long(dsta,newv);
  392. }}}}}}
  393. void op_50b0(UWORD opcode)
  394. {
  395.     ULONG srcreg = 8;
  396.     ULONG dstreg = (opcode & 7) >> 0;
  397. {{    ULONG src = srcreg;
  398. {    CPTR dsta = regs.a[dstreg];
  399.     UWORD dstdp = nextiword();
  400.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  401. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  402.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  403.     dsta += dstdpr;
  404. {    LONG dst = get_long(dsta);
  405. {    ULONG newv = dst + src;
  406. {    bool flgs = ((LONG)(src)) < 0;
  407.     bool flgo = ((LONG)(dst)) < 0;
  408.     bool flgn = ((LONG)(newv)) < 0;
  409.     regs.z = ((LONG)(newv)) == 0;
  410.     regs.v = (flgs == flgo) && (flgn != flgo);
  411.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  412.     regs.n = flgn != 0;
  413.     put_long(dsta,newv);
  414. }}}}}}}}
  415. void op_50b8(UWORD opcode)
  416. {
  417.     ULONG srcreg = 8;
  418. {{    ULONG src = srcreg;
  419. {    CPTR dsta = (LONG)(WORD)nextiword();
  420.     LONG dst = get_long(dsta);
  421. {    ULONG newv = dst + src;
  422. {    bool flgs = ((LONG)(src)) < 0;
  423.     bool flgo = ((LONG)(dst)) < 0;
  424.     bool flgn = ((LONG)(newv)) < 0;
  425.     regs.z = ((LONG)(newv)) == 0;
  426.     regs.v = (flgs == flgo) && (flgn != flgo);
  427.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  428.     regs.n = flgn != 0;
  429.     put_long(dsta,newv);
  430. }}}}}}
  431. void op_50b9(UWORD opcode)
  432. {
  433.     ULONG srcreg = 8;
  434. {{    ULONG src = srcreg;
  435. {    CPTR dsta = nextilong();
  436.     LONG dst = get_long(dsta);
  437. {    ULONG newv = dst + src;
  438. {    bool flgs = ((LONG)(src)) < 0;
  439.     bool flgo = ((LONG)(dst)) < 0;
  440.     bool flgn = ((LONG)(newv)) < 0;
  441.     regs.z = ((LONG)(newv)) == 0;
  442.     regs.v = (flgs == flgo) && (flgn != flgo);
  443.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  444.     regs.n = flgn != 0;
  445.     put_long(dsta,newv);
  446. }}}}}}
  447. void op_50c0(UWORD opcode)
  448. {
  449.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  450. {{{    int val = cctrue(0) ? 0xff : 0;
  451.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  452. }}}}
  453. void op_50c8(UWORD opcode)
  454. {
  455.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  456. {{    WORD src = regs.d[srcreg];
  457. {    WORD offs = nextiword();
  458.     if (!cctrue(0)) {
  459.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  460.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  461.     }
  462. }}}}
  463. void op_50d0(UWORD opcode)
  464. {
  465.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  466. {{    CPTR srca = regs.a[srcreg];
  467. {    int val = cctrue(0) ? 0xff : 0;
  468.     put_byte(srca,val);
  469. }}}}
  470. void op_50d8(UWORD opcode)
  471. {
  472.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  473. {{    CPTR srca = regs.a[srcreg];
  474. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  475. {    int val = cctrue(0) ? 0xff : 0;
  476.     put_byte(srca,val);
  477. }}}}}
  478. void op_50e0(UWORD opcode)
  479. {
  480.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  481. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  482. {    CPTR srca = regs.a[srcreg];
  483. {    int val = cctrue(0) ? 0xff : 0;
  484.     put_byte(srca,val);
  485. }}}}}
  486. void op_50e8(UWORD opcode)
  487. {
  488.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  489. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  490. {    int val = cctrue(0) ? 0xff : 0;
  491.     put_byte(srca,val);
  492. }}}}
  493. void op_50f0(UWORD opcode)
  494. {
  495.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  496. {{    CPTR srca = regs.a[srcreg];
  497.     UWORD srcdp = nextiword();
  498.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  499. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  500.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  501.     srca += srcdpr;
  502. {    int val = cctrue(0) ? 0xff : 0;
  503.     put_byte(srca,val);
  504. }}}}}
  505. void op_50f8(UWORD opcode)
  506. {
  507. {{    CPTR srca = (LONG)(WORD)nextiword();
  508. {    int val = cctrue(0) ? 0xff : 0;
  509.     put_byte(srca,val);
  510. }}}}
  511. void op_50f9(UWORD opcode)
  512. {
  513. {{    CPTR srca = nextilong();
  514. {    int val = cctrue(0) ? 0xff : 0;
  515.     put_byte(srca,val);
  516. }}}}
  517. void op_5100(UWORD opcode)
  518. {
  519.     ULONG srcreg = 8;
  520.     ULONG dstreg = (opcode & 7) >> 0;
  521. {{    ULONG src = srcreg;
  522. {    BYTE dst = regs.d[dstreg];
  523. {    ULONG newv = dst - src;
  524. {    bool flgs = ((BYTE)(src)) < 0;
  525.     bool flgo = ((BYTE)(dst)) < 0;
  526.     bool flgn = ((BYTE)(newv)) < 0;
  527.     regs.z = ((BYTE)(newv)) == 0;
  528.     regs.v = (flgs != flgo) && (flgn != flgo);
  529.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  530.     regs.n = flgn != 0;
  531.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  532. }}}}}}
  533. void op_5110(UWORD opcode)
  534. {
  535.     ULONG srcreg = 8;
  536.     ULONG dstreg = (opcode & 7) >> 0;
  537. {{    ULONG src = srcreg;
  538. {    CPTR dsta = regs.a[dstreg];
  539.     BYTE dst = get_byte(dsta);
  540. {    ULONG newv = dst - src;
  541. {    bool flgs = ((BYTE)(src)) < 0;
  542.     bool flgo = ((BYTE)(dst)) < 0;
  543.     bool flgn = ((BYTE)(newv)) < 0;
  544.     regs.z = ((BYTE)(newv)) == 0;
  545.     regs.v = (flgs != flgo) && (flgn != flgo);
  546.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  547.     regs.n = flgn != 0;
  548.     put_byte(dsta,newv);
  549. }}}}}}
  550. void op_5118(UWORD opcode)
  551. {
  552.     ULONG srcreg = 8;
  553.     ULONG dstreg = (opcode & 7) >> 0;
  554. {{    ULONG src = srcreg;
  555. {    CPTR dsta = regs.a[dstreg];
  556.     BYTE dst = get_byte(dsta);
  557. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  558. {    ULONG newv = dst - src;
  559. {    bool flgs = ((BYTE)(src)) < 0;
  560.     bool flgo = ((BYTE)(dst)) < 0;
  561.     bool flgn = ((BYTE)(newv)) < 0;
  562.     regs.z = ((BYTE)(newv)) == 0;
  563.     regs.v = (flgs != flgo) && (flgn != flgo);
  564.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  565.     regs.n = flgn != 0;
  566.     put_byte(dsta,newv);
  567. }}}}}}}
  568. void op_5120(UWORD opcode)
  569. {
  570.     ULONG srcreg = 8;
  571.     ULONG dstreg = (opcode & 7) >> 0;
  572. {{    ULONG src = srcreg;
  573. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  574. {    CPTR dsta = regs.a[dstreg];
  575.     BYTE dst = get_byte(dsta);
  576. {    ULONG newv = dst - src;
  577. {    bool flgs = ((BYTE)(src)) < 0;
  578.     bool flgo = ((BYTE)(dst)) < 0;
  579.     bool flgn = ((BYTE)(newv)) < 0;
  580.     regs.z = ((BYTE)(newv)) == 0;
  581.     regs.v = (flgs != flgo) && (flgn != flgo);
  582.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  583.     regs.n = flgn != 0;
  584.     put_byte(dsta,newv);
  585. }}}}}}}
  586. void op_5128(UWORD opcode)
  587. {
  588.     ULONG srcreg = 8;
  589.     ULONG dstreg = (opcode & 7) >> 0;
  590. {{    ULONG src = srcreg;
  591. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  592.     BYTE dst = get_byte(dsta);
  593. {    ULONG newv = dst - src;
  594. {    bool flgs = ((BYTE)(src)) < 0;
  595.     bool flgo = ((BYTE)(dst)) < 0;
  596.     bool flgn = ((BYTE)(newv)) < 0;
  597.     regs.z = ((BYTE)(newv)) == 0;
  598.     regs.v = (flgs != flgo) && (flgn != flgo);
  599.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  600.     regs.n = flgn != 0;
  601.     put_byte(dsta,newv);
  602. }}}}}}
  603. void op_5130(UWORD opcode)
  604. {
  605.     ULONG srcreg = 8;
  606.     ULONG dstreg = (opcode & 7) >> 0;
  607. {{    ULONG src = srcreg;
  608. {    CPTR dsta = regs.a[dstreg];
  609.     UWORD dstdp = nextiword();
  610.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  611. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  612.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  613.     dsta += dstdpr;
  614. {    BYTE dst = get_byte(dsta);
  615. {    ULONG newv = dst - src;
  616. {    bool flgs = ((BYTE)(src)) < 0;
  617.     bool flgo = ((BYTE)(dst)) < 0;
  618.     bool flgn = ((BYTE)(newv)) < 0;
  619.     regs.z = ((BYTE)(newv)) == 0;
  620.     regs.v = (flgs != flgo) && (flgn != flgo);
  621.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  622.     regs.n = flgn != 0;
  623.     put_byte(dsta,newv);
  624. }}}}}}}}
  625. void op_5138(UWORD opcode)
  626. {
  627.     ULONG srcreg = 8;
  628. {{    ULONG src = srcreg;
  629. {    CPTR dsta = (LONG)(WORD)nextiword();
  630.     BYTE dst = get_byte(dsta);
  631. {    ULONG newv = dst - src;
  632. {    bool flgs = ((BYTE)(src)) < 0;
  633.     bool flgo = ((BYTE)(dst)) < 0;
  634.     bool flgn = ((BYTE)(newv)) < 0;
  635.     regs.z = ((BYTE)(newv)) == 0;
  636.     regs.v = (flgs != flgo) && (flgn != flgo);
  637.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  638.     regs.n = flgn != 0;
  639.     put_byte(dsta,newv);
  640. }}}}}}
  641. void op_5139(UWORD opcode)
  642. {
  643.     ULONG srcreg = 8;
  644. {{    ULONG src = srcreg;
  645. {    CPTR dsta = nextilong();
  646.     BYTE dst = get_byte(dsta);
  647. {    ULONG newv = dst - src;
  648. {    bool flgs = ((BYTE)(src)) < 0;
  649.     bool flgo = ((BYTE)(dst)) < 0;
  650.     bool flgn = ((BYTE)(newv)) < 0;
  651.     regs.z = ((BYTE)(newv)) == 0;
  652.     regs.v = (flgs != flgo) && (flgn != flgo);
  653.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  654.     regs.n = flgn != 0;
  655.     put_byte(dsta,newv);
  656. }}}}}}
  657. void op_5140(UWORD opcode)
  658. {
  659.     ULONG srcreg = 8;
  660.     ULONG dstreg = (opcode & 7) >> 0;
  661. {{    ULONG src = srcreg;
  662. {    WORD dst = regs.d[dstreg];
  663. {    ULONG newv = dst - src;
  664. {    bool flgs = ((WORD)(src)) < 0;
  665.     bool flgo = ((WORD)(dst)) < 0;
  666.     bool flgn = ((WORD)(newv)) < 0;
  667.     regs.z = ((WORD)(newv)) == 0;
  668.     regs.v = (flgs != flgo) && (flgn != flgo);
  669.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  670.     regs.n = flgn != 0;
  671.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  672. }}}}}}
  673. void op_5148(UWORD opcode)
  674. {
  675.     ULONG srcreg = 8;
  676.     ULONG dstreg = (opcode & 7) >> 0;
  677. {{    ULONG src = srcreg;
  678. {    LONG dst = regs.a[dstreg];
  679. {    ULONG newv = dst - src;
  680.     regs.a[dstreg] = (newv);
  681. }}}}}
  682. void op_5150(UWORD opcode)
  683. {
  684.     ULONG srcreg = 8;
  685.     ULONG dstreg = (opcode & 7) >> 0;
  686. {{    ULONG src = srcreg;
  687. {    CPTR dsta = regs.a[dstreg];
  688.     WORD dst = get_word(dsta);
  689. {    ULONG newv = dst - src;
  690. {    bool flgs = ((WORD)(src)) < 0;
  691.     bool flgo = ((WORD)(dst)) < 0;
  692.     bool flgn = ((WORD)(newv)) < 0;
  693.     regs.z = ((WORD)(newv)) == 0;
  694.     regs.v = (flgs != flgo) && (flgn != flgo);
  695.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  696.     regs.n = flgn != 0;
  697.     put_word(dsta,newv);
  698. }}}}}}
  699. void op_5158(UWORD opcode)
  700. {
  701.     ULONG srcreg = 8;
  702.     ULONG dstreg = (opcode & 7) >> 0;
  703. {{    ULONG src = srcreg;
  704. {    CPTR dsta = regs.a[dstreg];
  705.     WORD dst = get_word(dsta);
  706. {    regs.a[dstreg] += 2;
  707. {    ULONG newv = dst - src;
  708. {    bool flgs = ((WORD)(src)) < 0;
  709.     bool flgo = ((WORD)(dst)) < 0;
  710.     bool flgn = ((WORD)(newv)) < 0;
  711.     regs.z = ((WORD)(newv)) == 0;
  712.     regs.v = (flgs != flgo) && (flgn != flgo);
  713.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  714.     regs.n = flgn != 0;
  715.     put_word(dsta,newv);
  716. }}}}}}}
  717. void op_5160(UWORD opcode)
  718. {
  719.     ULONG srcreg = 8;
  720.     ULONG dstreg = (opcode & 7) >> 0;
  721. {{    ULONG src = srcreg;
  722. {    regs.a[dstreg] -= 2;
  723. {    CPTR dsta = regs.a[dstreg];
  724.     WORD dst = get_word(dsta);
  725. {    ULONG newv = dst - src;
  726. {    bool flgs = ((WORD)(src)) < 0;
  727.     bool flgo = ((WORD)(dst)) < 0;
  728.     bool flgn = ((WORD)(newv)) < 0;
  729.     regs.z = ((WORD)(newv)) == 0;
  730.     regs.v = (flgs != flgo) && (flgn != flgo);
  731.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  732.     regs.n = flgn != 0;
  733.     put_word(dsta,newv);
  734. }}}}}}}
  735. void op_5168(UWORD opcode)
  736. {
  737.     ULONG srcreg = 8;
  738.     ULONG dstreg = (opcode & 7) >> 0;
  739. {{    ULONG src = srcreg;
  740. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  741.     WORD dst = get_word(dsta);
  742. {    ULONG newv = dst - src;
  743. {    bool flgs = ((WORD)(src)) < 0;
  744.     bool flgo = ((WORD)(dst)) < 0;
  745.     bool flgn = ((WORD)(newv)) < 0;
  746.     regs.z = ((WORD)(newv)) == 0;
  747.     regs.v = (flgs != flgo) && (flgn != flgo);
  748.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  749.     regs.n = flgn != 0;
  750.     put_word(dsta,newv);
  751. }}}}}}
  752. void op_5170(UWORD opcode)
  753. {
  754.     ULONG srcreg = 8;
  755.     ULONG dstreg = (opcode & 7) >> 0;
  756. {{    ULONG src = srcreg;
  757. {    CPTR dsta = regs.a[dstreg];
  758.     UWORD dstdp = nextiword();
  759.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  760. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  761.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  762.     dsta += dstdpr;
  763. {    WORD dst = get_word(dsta);
  764. {    ULONG newv = dst - src;
  765. {    bool flgs = ((WORD)(src)) < 0;
  766.     bool flgo = ((WORD)(dst)) < 0;
  767.     bool flgn = ((WORD)(newv)) < 0;
  768.     regs.z = ((WORD)(newv)) == 0;
  769.     regs.v = (flgs != flgo) && (flgn != flgo);
  770.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  771.     regs.n = flgn != 0;
  772.     put_word(dsta,newv);
  773. }}}}}}}}
  774. void op_5178(UWORD opcode)
  775. {
  776.     ULONG srcreg = 8;
  777. {{    ULONG src = srcreg;
  778. {    CPTR dsta = (LONG)(WORD)nextiword();
  779.     WORD dst = get_word(dsta);
  780. {    ULONG newv = dst - src;
  781. {    bool flgs = ((WORD)(src)) < 0;
  782.     bool flgo = ((WORD)(dst)) < 0;
  783.     bool flgn = ((WORD)(newv)) < 0;
  784.     regs.z = ((WORD)(newv)) == 0;
  785.     regs.v = (flgs != flgo) && (flgn != flgo);
  786.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  787.     regs.n = flgn != 0;
  788.     put_word(dsta,newv);
  789. }}}}}}
  790. void op_5179(UWORD opcode)
  791. {
  792.     ULONG srcreg = 8;
  793. {{    ULONG src = srcreg;
  794. {    CPTR dsta = nextilong();
  795.     WORD dst = get_word(dsta);
  796. {    ULONG newv = dst - src;
  797. {    bool flgs = ((WORD)(src)) < 0;
  798.     bool flgo = ((WORD)(dst)) < 0;
  799.     bool flgn = ((WORD)(newv)) < 0;
  800.     regs.z = ((WORD)(newv)) == 0;
  801.     regs.v = (flgs != flgo) && (flgn != flgo);
  802.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  803.     regs.n = flgn != 0;
  804.     put_word(dsta,newv);
  805. }}}}}}
  806. void op_5180(UWORD opcode)
  807. {
  808.     ULONG srcreg = 8;
  809.     ULONG dstreg = (opcode & 7) >> 0;
  810. {{    ULONG src = srcreg;
  811. {    LONG dst = regs.d[dstreg];
  812. {    ULONG newv = dst - src;
  813. {    bool flgs = ((LONG)(src)) < 0;
  814.     bool flgo = ((LONG)(dst)) < 0;
  815.     bool flgn = ((LONG)(newv)) < 0;
  816.     regs.z = ((LONG)(newv)) == 0;
  817.     regs.v = (flgs != flgo) && (flgn != flgo);
  818.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  819.     regs.n = flgn != 0;
  820.     regs.d[dstreg] = (newv);
  821. }}}}}}
  822. void op_5188(UWORD opcode)
  823. {
  824.     ULONG srcreg = 8;
  825.     ULONG dstreg = (opcode & 7) >> 0;
  826. {{    ULONG src = srcreg;
  827. {    LONG dst = regs.a[dstreg];
  828. {    ULONG newv = dst - src;
  829.     regs.a[dstreg] = (newv);
  830. }}}}}
  831. void op_5190(UWORD opcode)
  832. {
  833.     ULONG srcreg = 8;
  834.     ULONG dstreg = (opcode & 7) >> 0;
  835. {{    ULONG src = srcreg;
  836. {    CPTR dsta = regs.a[dstreg];
  837.     LONG dst = get_long(dsta);
  838. {    ULONG newv = dst - src;
  839. {    bool flgs = ((LONG)(src)) < 0;
  840.     bool flgo = ((LONG)(dst)) < 0;
  841.     bool flgn = ((LONG)(newv)) < 0;
  842.     regs.z = ((LONG)(newv)) == 0;
  843.     regs.v = (flgs != flgo) && (flgn != flgo);
  844.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  845.     regs.n = flgn != 0;
  846.     put_long(dsta,newv);
  847. }}}}}}
  848. void op_5198(UWORD opcode)
  849. {
  850.     ULONG srcreg = 8;
  851.     ULONG dstreg = (opcode & 7) >> 0;
  852. {{    ULONG src = srcreg;
  853. {    CPTR dsta = regs.a[dstreg];
  854.     LONG dst = get_long(dsta);
  855. {    regs.a[dstreg] += 4;
  856. {    ULONG newv = dst - src;
  857. {    bool flgs = ((LONG)(src)) < 0;
  858.     bool flgo = ((LONG)(dst)) < 0;
  859.     bool flgn = ((LONG)(newv)) < 0;
  860.     regs.z = ((LONG)(newv)) == 0;
  861.     regs.v = (flgs != flgo) && (flgn != flgo);
  862.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  863.     regs.n = flgn != 0;
  864.     put_long(dsta,newv);
  865. }}}}}}}
  866. void op_51a0(UWORD opcode)
  867. {
  868.     ULONG srcreg = 8;
  869.     ULONG dstreg = (opcode & 7) >> 0;
  870. {{    ULONG src = srcreg;
  871. {    regs.a[dstreg] -= 4;
  872. {    CPTR dsta = regs.a[dstreg];
  873.     LONG dst = get_long(dsta);
  874. {    ULONG newv = dst - src;
  875. {    bool flgs = ((LONG)(src)) < 0;
  876.     bool flgo = ((LONG)(dst)) < 0;
  877.     bool flgn = ((LONG)(newv)) < 0;
  878.     regs.z = ((LONG)(newv)) == 0;
  879.     regs.v = (flgs != flgo) && (flgn != flgo);
  880.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  881.     regs.n = flgn != 0;
  882.     put_long(dsta,newv);
  883. }}}}}}}
  884. void op_51a8(UWORD opcode)
  885. {
  886.     ULONG srcreg = 8;
  887.     ULONG dstreg = (opcode & 7) >> 0;
  888. {{    ULONG src = srcreg;
  889. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  890.     LONG dst = get_long(dsta);
  891. {    ULONG newv = dst - src;
  892. {    bool flgs = ((LONG)(src)) < 0;
  893.     bool flgo = ((LONG)(dst)) < 0;
  894.     bool flgn = ((LONG)(newv)) < 0;
  895.     regs.z = ((LONG)(newv)) == 0;
  896.     regs.v = (flgs != flgo) && (flgn != flgo);
  897.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  898.     regs.n = flgn != 0;
  899.     put_long(dsta,newv);
  900. }}}}}}
  901. void op_51b0(UWORD opcode)
  902. {
  903.     ULONG srcreg = 8;
  904.     ULONG dstreg = (opcode & 7) >> 0;
  905. {{    ULONG src = srcreg;
  906. {    CPTR dsta = regs.a[dstreg];
  907.     UWORD dstdp = nextiword();
  908.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  909. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  910.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  911.     dsta += dstdpr;
  912. {    LONG dst = get_long(dsta);
  913. {    ULONG newv = dst - src;
  914. {    bool flgs = ((LONG)(src)) < 0;
  915.     bool flgo = ((LONG)(dst)) < 0;
  916.     bool flgn = ((LONG)(newv)) < 0;
  917.     regs.z = ((LONG)(newv)) == 0;
  918.     regs.v = (flgs != flgo) && (flgn != flgo);
  919.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  920.     regs.n = flgn != 0;
  921.     put_long(dsta,newv);
  922. }}}}}}}}
  923. void op_51b8(UWORD opcode)
  924. {
  925.     ULONG srcreg = 8;
  926. {{    ULONG src = srcreg;
  927. {    CPTR dsta = (LONG)(WORD)nextiword();
  928.     LONG dst = get_long(dsta);
  929. {    ULONG newv = dst - src;
  930. {    bool flgs = ((LONG)(src)) < 0;
  931.     bool flgo = ((LONG)(dst)) < 0;
  932.     bool flgn = ((LONG)(newv)) < 0;
  933.     regs.z = ((LONG)(newv)) == 0;
  934.     regs.v = (flgs != flgo) && (flgn != flgo);
  935.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  936.     regs.n = flgn != 0;
  937.     put_long(dsta,newv);
  938. }}}}}}
  939. void op_51b9(UWORD opcode)
  940. {
  941.     ULONG srcreg = 8;
  942. {{    ULONG src = srcreg;
  943. {    CPTR dsta = nextilong();
  944.     LONG dst = get_long(dsta);
  945. {    ULONG newv = dst - src;
  946. {    bool flgs = ((LONG)(src)) < 0;
  947.     bool flgo = ((LONG)(dst)) < 0;
  948.     bool flgn = ((LONG)(newv)) < 0;
  949.     regs.z = ((LONG)(newv)) == 0;
  950.     regs.v = (flgs != flgo) && (flgn != flgo);
  951.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  952.     regs.n = flgn != 0;
  953.     put_long(dsta,newv);
  954. }}}}}}
  955. void op_51c0(UWORD opcode)
  956. {
  957.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  958. {{{    int val = cctrue(1) ? 0xff : 0;
  959.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  960. }}}}
  961. void op_51c8(UWORD opcode)
  962. {
  963.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  964. {{    WORD src = regs.d[srcreg];
  965. {    WORD offs = nextiword();
  966.     if (!cctrue(1)) {
  967.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  968.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  969.     }
  970. }}}}
  971. void op_51d0(UWORD opcode)
  972. {
  973.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  974. {{    CPTR srca = regs.a[srcreg];
  975. {    int val = cctrue(1) ? 0xff : 0;
  976.     put_byte(srca,val);
  977. }}}}
  978. void op_51d8(UWORD opcode)
  979. {
  980.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  981. {{    CPTR srca = regs.a[srcreg];
  982. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  983. {    int val = cctrue(1) ? 0xff : 0;
  984.     put_byte(srca,val);
  985. }}}}}
  986. void op_51e0(UWORD opcode)
  987. {
  988.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  989. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  990. {    CPTR srca = regs.a[srcreg];
  991. {    int val = cctrue(1) ? 0xff : 0;
  992.     put_byte(srca,val);
  993. }}}}}
  994. void op_51e8(UWORD opcode)
  995. {
  996.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  997. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  998. {    int val = cctrue(1) ? 0xff : 0;
  999.     put_byte(srca,val);
  1000. }}}}
  1001. void op_51f0(UWORD opcode)
  1002. {
  1003.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1004. {{    CPTR srca = regs.a[srcreg];
  1005.     UWORD srcdp = nextiword();
  1006.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1007. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1008.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1009.     srca += srcdpr;
  1010. {    int val = cctrue(1) ? 0xff : 0;
  1011.     put_byte(srca,val);
  1012. }}}}}
  1013. void op_51f8(UWORD opcode)
  1014. {
  1015. {{    CPTR srca = (LONG)(WORD)nextiword();
  1016. {    int val = cctrue(1) ? 0xff : 0;
  1017.     put_byte(srca,val);
  1018. }}}}
  1019. void op_51f9(UWORD opcode)
  1020. {
  1021. {{    CPTR srca = nextilong();
  1022. {    int val = cctrue(1) ? 0xff : 0;
  1023.     put_byte(srca,val);
  1024. }}}}
  1025. void op_5200(UWORD opcode)
  1026. {
  1027.     ULONG srcreg = 1;
  1028.     ULONG dstreg = (opcode & 7) >> 0;
  1029. {{    ULONG src = srcreg;
  1030. {    BYTE dst = regs.d[dstreg];
  1031. {    ULONG newv = dst + src;
  1032. {    bool flgs = ((BYTE)(src)) < 0;
  1033.     bool flgo = ((BYTE)(dst)) < 0;
  1034.     bool flgn = ((BYTE)(newv)) < 0;
  1035.     regs.z = ((BYTE)(newv)) == 0;
  1036.     regs.v = (flgs == flgo) && (flgn != flgo);
  1037.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1038.     regs.n = flgn != 0;
  1039.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  1040. }}}}}}
  1041. void op_5210(UWORD opcode)
  1042. {
  1043.     ULONG srcreg = 1;
  1044.     ULONG dstreg = (opcode & 7) >> 0;
  1045. {{    ULONG src = srcreg;
  1046. {    CPTR dsta = regs.a[dstreg];
  1047.     BYTE dst = get_byte(dsta);
  1048. {    ULONG newv = dst + src;
  1049. {    bool flgs = ((BYTE)(src)) < 0;
  1050.     bool flgo = ((BYTE)(dst)) < 0;
  1051.     bool flgn = ((BYTE)(newv)) < 0;
  1052.     regs.z = ((BYTE)(newv)) == 0;
  1053.     regs.v = (flgs == flgo) && (flgn != flgo);
  1054.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1055.     regs.n = flgn != 0;
  1056.     put_byte(dsta,newv);
  1057. }}}}}}
  1058. void op_5218(UWORD opcode)
  1059. {
  1060.     ULONG srcreg = 1;
  1061.     ULONG dstreg = (opcode & 7) >> 0;
  1062. {{    ULONG src = srcreg;
  1063. {    CPTR dsta = regs.a[dstreg];
  1064.     BYTE dst = get_byte(dsta);
  1065. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1066. {    ULONG newv = dst + src;
  1067. {    bool flgs = ((BYTE)(src)) < 0;
  1068.     bool flgo = ((BYTE)(dst)) < 0;
  1069.     bool flgn = ((BYTE)(newv)) < 0;
  1070.     regs.z = ((BYTE)(newv)) == 0;
  1071.     regs.v = (flgs == flgo) && (flgn != flgo);
  1072.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1073.     regs.n = flgn != 0;
  1074.     put_byte(dsta,newv);
  1075. }}}}}}}
  1076. void op_5220(UWORD opcode)
  1077. {
  1078.     ULONG srcreg = 1;
  1079.     ULONG dstreg = (opcode & 7) >> 0;
  1080. {{    ULONG src = srcreg;
  1081. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1082. {    CPTR dsta = regs.a[dstreg];
  1083.     BYTE dst = get_byte(dsta);
  1084. {    ULONG newv = dst + src;
  1085. {    bool flgs = ((BYTE)(src)) < 0;
  1086.     bool flgo = ((BYTE)(dst)) < 0;
  1087.     bool flgn = ((BYTE)(newv)) < 0;
  1088.     regs.z = ((BYTE)(newv)) == 0;
  1089.     regs.v = (flgs == flgo) && (flgn != flgo);
  1090.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1091.     regs.n = flgn != 0;
  1092.     put_byte(dsta,newv);
  1093. }}}}}}}
  1094. void op_5228(UWORD opcode)
  1095. {
  1096.     ULONG srcreg = 1;
  1097.     ULONG dstreg = (opcode & 7) >> 0;
  1098. {{    ULONG src = srcreg;
  1099. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1100.     BYTE dst = get_byte(dsta);
  1101. {    ULONG newv = dst + src;
  1102. {    bool flgs = ((BYTE)(src)) < 0;
  1103.     bool flgo = ((BYTE)(dst)) < 0;
  1104.     bool flgn = ((BYTE)(newv)) < 0;
  1105.     regs.z = ((BYTE)(newv)) == 0;
  1106.     regs.v = (flgs == flgo) && (flgn != flgo);
  1107.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1108.     regs.n = flgn != 0;
  1109.     put_byte(dsta,newv);
  1110. }}}}}}
  1111. void op_5230(UWORD opcode)
  1112. {
  1113.     ULONG srcreg = 1;
  1114.     ULONG dstreg = (opcode & 7) >> 0;
  1115. {{    ULONG src = srcreg;
  1116. {    CPTR dsta = regs.a[dstreg];
  1117.     UWORD dstdp = nextiword();
  1118.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1119. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1120.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1121.     dsta += dstdpr;
  1122. {    BYTE dst = get_byte(dsta);
  1123. {    ULONG newv = dst + src;
  1124. {    bool flgs = ((BYTE)(src)) < 0;
  1125.     bool flgo = ((BYTE)(dst)) < 0;
  1126.     bool flgn = ((BYTE)(newv)) < 0;
  1127.     regs.z = ((BYTE)(newv)) == 0;
  1128.     regs.v = (flgs == flgo) && (flgn != flgo);
  1129.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1130.     regs.n = flgn != 0;
  1131.     put_byte(dsta,newv);
  1132. }}}}}}}}
  1133. void op_5238(UWORD opcode)
  1134. {
  1135.     ULONG srcreg = 1;
  1136. {{    ULONG src = srcreg;
  1137. {    CPTR dsta = (LONG)(WORD)nextiword();
  1138.     BYTE dst = get_byte(dsta);
  1139. {    ULONG newv = dst + src;
  1140. {    bool flgs = ((BYTE)(src)) < 0;
  1141.     bool flgo = ((BYTE)(dst)) < 0;
  1142.     bool flgn = ((BYTE)(newv)) < 0;
  1143.     regs.z = ((BYTE)(newv)) == 0;
  1144.     regs.v = (flgs == flgo) && (flgn != flgo);
  1145.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1146.     regs.n = flgn != 0;
  1147.     put_byte(dsta,newv);
  1148. }}}}}}
  1149. void op_5239(UWORD opcode)
  1150. {
  1151.     ULONG srcreg = 1;
  1152. {{    ULONG src = srcreg;
  1153. {    CPTR dsta = nextilong();
  1154.     BYTE dst = get_byte(dsta);
  1155. {    ULONG newv = dst + src;
  1156. {    bool flgs = ((BYTE)(src)) < 0;
  1157.     bool flgo = ((BYTE)(dst)) < 0;
  1158.     bool flgn = ((BYTE)(newv)) < 0;
  1159.     regs.z = ((BYTE)(newv)) == 0;
  1160.     regs.v = (flgs == flgo) && (flgn != flgo);
  1161.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1162.     regs.n = flgn != 0;
  1163.     put_byte(dsta,newv);
  1164. }}}}}}
  1165. void op_5240(UWORD opcode)
  1166. {
  1167.     ULONG srcreg = 1;
  1168.     ULONG dstreg = (opcode & 7) >> 0;
  1169. {{    ULONG src = srcreg;
  1170. {    WORD dst = regs.d[dstreg];
  1171. {    ULONG newv = dst + src;
  1172. {    bool flgs = ((WORD)(src)) < 0;
  1173.     bool flgo = ((WORD)(dst)) < 0;
  1174.     bool flgn = ((WORD)(newv)) < 0;
  1175.     regs.z = ((WORD)(newv)) == 0;
  1176.     regs.v = (flgs == flgo) && (flgn != flgo);
  1177.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1178.     regs.n = flgn != 0;
  1179.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  1180. }}}}}}
  1181. void op_5248(UWORD opcode)
  1182. {
  1183.     ULONG srcreg = 1;
  1184.     ULONG dstreg = (opcode & 7) >> 0;
  1185. {{    ULONG src = srcreg;
  1186. {    LONG dst = regs.a[dstreg];
  1187. {    ULONG newv = dst + src;
  1188.     regs.a[dstreg] = (newv);
  1189. }}}}}
  1190. void op_5250(UWORD opcode)
  1191. {
  1192.     ULONG srcreg = 1;
  1193.     ULONG dstreg = (opcode & 7) >> 0;
  1194. {{    ULONG src = srcreg;
  1195. {    CPTR dsta = regs.a[dstreg];
  1196.     WORD dst = get_word(dsta);
  1197. {    ULONG newv = dst + src;
  1198. {    bool flgs = ((WORD)(src)) < 0;
  1199.     bool flgo = ((WORD)(dst)) < 0;
  1200.     bool flgn = ((WORD)(newv)) < 0;
  1201.     regs.z = ((WORD)(newv)) == 0;
  1202.     regs.v = (flgs == flgo) && (flgn != flgo);
  1203.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1204.     regs.n = flgn != 0;
  1205.     put_word(dsta,newv);
  1206. }}}}}}
  1207. void op_5258(UWORD opcode)
  1208. {
  1209.     ULONG srcreg = 1;
  1210.     ULONG dstreg = (opcode & 7) >> 0;
  1211. {{    ULONG src = srcreg;
  1212. {    CPTR dsta = regs.a[dstreg];
  1213.     WORD dst = get_word(dsta);
  1214. {    regs.a[dstreg] += 2;
  1215. {    ULONG newv = dst + src;
  1216. {    bool flgs = ((WORD)(src)) < 0;
  1217.     bool flgo = ((WORD)(dst)) < 0;
  1218.     bool flgn = ((WORD)(newv)) < 0;
  1219.     regs.z = ((WORD)(newv)) == 0;
  1220.     regs.v = (flgs == flgo) && (flgn != flgo);
  1221.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1222.     regs.n = flgn != 0;
  1223.     put_word(dsta,newv);
  1224. }}}}}}}
  1225. void op_5260(UWORD opcode)
  1226. {
  1227.     ULONG srcreg = 1;
  1228.     ULONG dstreg = (opcode & 7) >> 0;
  1229. {{    ULONG src = srcreg;
  1230. {    regs.a[dstreg] -= 2;
  1231. {    CPTR dsta = regs.a[dstreg];
  1232.     WORD dst = get_word(dsta);
  1233. {    ULONG newv = dst + src;
  1234. {    bool flgs = ((WORD)(src)) < 0;
  1235.     bool flgo = ((WORD)(dst)) < 0;
  1236.     bool flgn = ((WORD)(newv)) < 0;
  1237.     regs.z = ((WORD)(newv)) == 0;
  1238.     regs.v = (flgs == flgo) && (flgn != flgo);
  1239.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1240.     regs.n = flgn != 0;
  1241.     put_word(dsta,newv);
  1242. }}}}}}}
  1243. void op_5268(UWORD opcode)
  1244. {
  1245.     ULONG srcreg = 1;
  1246.     ULONG dstreg = (opcode & 7) >> 0;
  1247. {{    ULONG src = srcreg;
  1248. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1249.     WORD dst = get_word(dsta);
  1250. {    ULONG newv = dst + src;
  1251. {    bool flgs = ((WORD)(src)) < 0;
  1252.     bool flgo = ((WORD)(dst)) < 0;
  1253.     bool flgn = ((WORD)(newv)) < 0;
  1254.     regs.z = ((WORD)(newv)) == 0;
  1255.     regs.v = (flgs == flgo) && (flgn != flgo);
  1256.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1257.     regs.n = flgn != 0;
  1258.     put_word(dsta,newv);
  1259. }}}}}}
  1260. void op_5270(UWORD opcode)
  1261. {
  1262.     ULONG srcreg = 1;
  1263.     ULONG dstreg = (opcode & 7) >> 0;
  1264. {{    ULONG src = srcreg;
  1265. {    CPTR dsta = regs.a[dstreg];
  1266.     UWORD dstdp = nextiword();
  1267.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1268. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1269.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1270.     dsta += dstdpr;
  1271. {    WORD dst = get_word(dsta);
  1272. {    ULONG newv = dst + src;
  1273. {    bool flgs = ((WORD)(src)) < 0;
  1274.     bool flgo = ((WORD)(dst)) < 0;
  1275.     bool flgn = ((WORD)(newv)) < 0;
  1276.     regs.z = ((WORD)(newv)) == 0;
  1277.     regs.v = (flgs == flgo) && (flgn != flgo);
  1278.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1279.     regs.n = flgn != 0;
  1280.     put_word(dsta,newv);
  1281. }}}}}}}}
  1282. void op_5278(UWORD opcode)
  1283. {
  1284.     ULONG srcreg = 1;
  1285. {{    ULONG src = srcreg;
  1286. {    CPTR dsta = (LONG)(WORD)nextiword();
  1287.     WORD dst = get_word(dsta);
  1288. {    ULONG newv = dst + src;
  1289. {    bool flgs = ((WORD)(src)) < 0;
  1290.     bool flgo = ((WORD)(dst)) < 0;
  1291.     bool flgn = ((WORD)(newv)) < 0;
  1292.     regs.z = ((WORD)(newv)) == 0;
  1293.     regs.v = (flgs == flgo) && (flgn != flgo);
  1294.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1295.     regs.n = flgn != 0;
  1296.     put_word(dsta,newv);
  1297. }}}}}}
  1298. void op_5279(UWORD opcode)
  1299. {
  1300.     ULONG srcreg = 1;
  1301. {{    ULONG src = srcreg;
  1302. {    CPTR dsta = nextilong();
  1303.     WORD dst = get_word(dsta);
  1304. {    ULONG newv = dst + src;
  1305. {    bool flgs = ((WORD)(src)) < 0;
  1306.     bool flgo = ((WORD)(dst)) < 0;
  1307.     bool flgn = ((WORD)(newv)) < 0;
  1308.     regs.z = ((WORD)(newv)) == 0;
  1309.     regs.v = (flgs == flgo) && (flgn != flgo);
  1310.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1311.     regs.n = flgn != 0;
  1312.     put_word(dsta,newv);
  1313. }}}}}}
  1314. void op_5280(UWORD opcode)
  1315. {
  1316.     ULONG srcreg = 1;
  1317.     ULONG dstreg = (opcode & 7) >> 0;
  1318. {{    ULONG src = srcreg;
  1319. {    LONG dst = regs.d[dstreg];
  1320. {    ULONG newv = dst + src;
  1321. {    bool flgs = ((LONG)(src)) < 0;
  1322.     bool flgo = ((LONG)(dst)) < 0;
  1323.     bool flgn = ((LONG)(newv)) < 0;
  1324.     regs.z = ((LONG)(newv)) == 0;
  1325.     regs.v = (flgs == flgo) && (flgn != flgo);
  1326.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1327.     regs.n = flgn != 0;
  1328.     regs.d[dstreg] = (newv);
  1329. }}}}}}
  1330. void op_5288(UWORD opcode)
  1331. {
  1332.     ULONG srcreg = 1;
  1333.     ULONG dstreg = (opcode & 7) >> 0;
  1334. {{    ULONG src = srcreg;
  1335. {    LONG dst = regs.a[dstreg];
  1336. {    ULONG newv = dst + src;
  1337.     regs.a[dstreg] = (newv);
  1338. }}}}}
  1339. void op_5290(UWORD opcode)
  1340. {
  1341.     ULONG srcreg = 1;
  1342.     ULONG dstreg = (opcode & 7) >> 0;
  1343. {{    ULONG src = srcreg;
  1344. {    CPTR dsta = regs.a[dstreg];
  1345.     LONG dst = get_long(dsta);
  1346. {    ULONG newv = dst + src;
  1347. {    bool flgs = ((LONG)(src)) < 0;
  1348.     bool flgo = ((LONG)(dst)) < 0;
  1349.     bool flgn = ((LONG)(newv)) < 0;
  1350.     regs.z = ((LONG)(newv)) == 0;
  1351.     regs.v = (flgs == flgo) && (flgn != flgo);
  1352.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1353.     regs.n = flgn != 0;
  1354.     put_long(dsta,newv);
  1355. }}}}}}
  1356. void op_5298(UWORD opcode)
  1357. {
  1358.     ULONG srcreg = 1;
  1359.     ULONG dstreg = (opcode & 7) >> 0;
  1360. {{    ULONG src = srcreg;
  1361. {    CPTR dsta = regs.a[dstreg];
  1362.     LONG dst = get_long(dsta);
  1363. {    regs.a[dstreg] += 4;
  1364. {    ULONG newv = dst + src;
  1365. {    bool flgs = ((LONG)(src)) < 0;
  1366.     bool flgo = ((LONG)(dst)) < 0;
  1367.     bool flgn = ((LONG)(newv)) < 0;
  1368.     regs.z = ((LONG)(newv)) == 0;
  1369.     regs.v = (flgs == flgo) && (flgn != flgo);
  1370.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1371.     regs.n = flgn != 0;
  1372.     put_long(dsta,newv);
  1373. }}}}}}}
  1374. void op_52a0(UWORD opcode)
  1375. {
  1376.     ULONG srcreg = 1;
  1377.     ULONG dstreg = (opcode & 7) >> 0;
  1378. {{    ULONG src = srcreg;
  1379. {    regs.a[dstreg] -= 4;
  1380. {    CPTR dsta = regs.a[dstreg];
  1381.     LONG dst = get_long(dsta);
  1382. {    ULONG newv = dst + src;
  1383. {    bool flgs = ((LONG)(src)) < 0;
  1384.     bool flgo = ((LONG)(dst)) < 0;
  1385.     bool flgn = ((LONG)(newv)) < 0;
  1386.     regs.z = ((LONG)(newv)) == 0;
  1387.     regs.v = (flgs == flgo) && (flgn != flgo);
  1388.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1389.     regs.n = flgn != 0;
  1390.     put_long(dsta,newv);
  1391. }}}}}}}
  1392. void op_52a8(UWORD opcode)
  1393. {
  1394.     ULONG srcreg = 1;
  1395.     ULONG dstreg = (opcode & 7) >> 0;
  1396. {{    ULONG src = srcreg;
  1397. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1398.     LONG dst = get_long(dsta);
  1399. {    ULONG newv = dst + src;
  1400. {    bool flgs = ((LONG)(src)) < 0;
  1401.     bool flgo = ((LONG)(dst)) < 0;
  1402.     bool flgn = ((LONG)(newv)) < 0;
  1403.     regs.z = ((LONG)(newv)) == 0;
  1404.     regs.v = (flgs == flgo) && (flgn != flgo);
  1405.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1406.     regs.n = flgn != 0;
  1407.     put_long(dsta,newv);
  1408. }}}}}}
  1409. void op_52b0(UWORD opcode)
  1410. {
  1411.     ULONG srcreg = 1;
  1412.     ULONG dstreg = (opcode & 7) >> 0;
  1413. {{    ULONG src = srcreg;
  1414. {    CPTR dsta = regs.a[dstreg];
  1415.     UWORD dstdp = nextiword();
  1416.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1417. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1418.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1419.     dsta += dstdpr;
  1420. {    LONG dst = get_long(dsta);
  1421. {    ULONG newv = dst + src;
  1422. {    bool flgs = ((LONG)(src)) < 0;
  1423.     bool flgo = ((LONG)(dst)) < 0;
  1424.     bool flgn = ((LONG)(newv)) < 0;
  1425.     regs.z = ((LONG)(newv)) == 0;
  1426.     regs.v = (flgs == flgo) && (flgn != flgo);
  1427.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1428.     regs.n = flgn != 0;
  1429.     put_long(dsta,newv);
  1430. }}}}}}}}
  1431. void op_52b8(UWORD opcode)
  1432. {
  1433.     ULONG srcreg = 1;
  1434. {{    ULONG src = srcreg;
  1435. {    CPTR dsta = (LONG)(WORD)nextiword();
  1436.     LONG dst = get_long(dsta);
  1437. {    ULONG newv = dst + src;
  1438. {    bool flgs = ((LONG)(src)) < 0;
  1439.     bool flgo = ((LONG)(dst)) < 0;
  1440.     bool flgn = ((LONG)(newv)) < 0;
  1441.     regs.z = ((LONG)(newv)) == 0;
  1442.     regs.v = (flgs == flgo) && (flgn != flgo);
  1443.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1444.     regs.n = flgn != 0;
  1445.     put_long(dsta,newv);
  1446. }}}}}}
  1447. void op_52b9(UWORD opcode)
  1448. {
  1449.     ULONG srcreg = 1;
  1450. {{    ULONG src = srcreg;
  1451. {    CPTR dsta = nextilong();
  1452.     LONG dst = get_long(dsta);
  1453. {    ULONG newv = dst + src;
  1454. {    bool flgs = ((LONG)(src)) < 0;
  1455.     bool flgo = ((LONG)(dst)) < 0;
  1456.     bool flgn = ((LONG)(newv)) < 0;
  1457.     regs.z = ((LONG)(newv)) == 0;
  1458.     regs.v = (flgs == flgo) && (flgn != flgo);
  1459.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1460.     regs.n = flgn != 0;
  1461.     put_long(dsta,newv);
  1462. }}}}}}
  1463. void op_52c0(UWORD opcode)
  1464. {
  1465.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1466. {{{    int val = cctrue(2) ? 0xff : 0;
  1467.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  1468. }}}}
  1469. void op_52c8(UWORD opcode)
  1470. {
  1471.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1472. {{    WORD src = regs.d[srcreg];
  1473. {    WORD offs = nextiword();
  1474.     if (!cctrue(2)) {
  1475.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  1476.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  1477.     }
  1478. }}}}
  1479. void op_52d0(UWORD opcode)
  1480. {
  1481.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1482. {{    CPTR srca = regs.a[srcreg];
  1483. {    int val = cctrue(2) ? 0xff : 0;
  1484.     put_byte(srca,val);
  1485. }}}}
  1486. void op_52d8(UWORD opcode)
  1487. {
  1488.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1489. {{    CPTR srca = regs.a[srcreg];
  1490. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  1491. {    int val = cctrue(2) ? 0xff : 0;
  1492.     put_byte(srca,val);
  1493. }}}}}
  1494. void op_52e0(UWORD opcode)
  1495. {
  1496.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1497. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  1498. {    CPTR srca = regs.a[srcreg];
  1499. {    int val = cctrue(2) ? 0xff : 0;
  1500.     put_byte(srca,val);
  1501. }}}}}
  1502. void op_52e8(UWORD opcode)
  1503. {
  1504.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1505. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  1506. {    int val = cctrue(2) ? 0xff : 0;
  1507.     put_byte(srca,val);
  1508. }}}}
  1509. void op_52f0(UWORD opcode)
  1510. {
  1511.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1512. {{    CPTR srca = regs.a[srcreg];
  1513.     UWORD srcdp = nextiword();
  1514.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1515. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1516.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1517.     srca += srcdpr;
  1518. {    int val = cctrue(2) ? 0xff : 0;
  1519.     put_byte(srca,val);
  1520. }}}}}
  1521. void op_52f8(UWORD opcode)
  1522. {
  1523. {{    CPTR srca = (LONG)(WORD)nextiword();
  1524. {    int val = cctrue(2) ? 0xff : 0;
  1525.     put_byte(srca,val);
  1526. }}}}
  1527. void op_52f9(UWORD opcode)
  1528. {
  1529. {{    CPTR srca = nextilong();
  1530. {    int val = cctrue(2) ? 0xff : 0;
  1531.     put_byte(srca,val);
  1532. }}}}
  1533. void op_5300(UWORD opcode)
  1534. {
  1535.     ULONG srcreg = 1;
  1536.     ULONG dstreg = (opcode & 7) >> 0;
  1537. {{    ULONG src = srcreg;
  1538. {    BYTE dst = regs.d[dstreg];
  1539. {    ULONG newv = dst - src;
  1540. {    bool flgs = ((BYTE)(src)) < 0;
  1541.     bool flgo = ((BYTE)(dst)) < 0;
  1542.     bool flgn = ((BYTE)(newv)) < 0;
  1543.     regs.z = ((BYTE)(newv)) == 0;
  1544.     regs.v = (flgs != flgo) && (flgn != flgo);
  1545.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1546.     regs.n = flgn != 0;
  1547.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  1548. }}}}}}
  1549. void op_5310(UWORD opcode)
  1550. {
  1551.     ULONG srcreg = 1;
  1552.     ULONG dstreg = (opcode & 7) >> 0;
  1553. {{    ULONG src = srcreg;
  1554. {    CPTR dsta = regs.a[dstreg];
  1555.     BYTE dst = get_byte(dsta);
  1556. {    ULONG newv = dst - src;
  1557. {    bool flgs = ((BYTE)(src)) < 0;
  1558.     bool flgo = ((BYTE)(dst)) < 0;
  1559.     bool flgn = ((BYTE)(newv)) < 0;
  1560.     regs.z = ((BYTE)(newv)) == 0;
  1561.     regs.v = (flgs != flgo) && (flgn != flgo);
  1562.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1563.     regs.n = flgn != 0;
  1564.     put_byte(dsta,newv);
  1565. }}}}}}
  1566. void op_5318(UWORD opcode)
  1567. {
  1568.     ULONG srcreg = 1;
  1569.     ULONG dstreg = (opcode & 7) >> 0;
  1570. {{    ULONG src = srcreg;
  1571. {    CPTR dsta = regs.a[dstreg];
  1572.     BYTE dst = get_byte(dsta);
  1573. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1574. {    ULONG newv = dst - src;
  1575. {    bool flgs = ((BYTE)(src)) < 0;
  1576.     bool flgo = ((BYTE)(dst)) < 0;
  1577.     bool flgn = ((BYTE)(newv)) < 0;
  1578.     regs.z = ((BYTE)(newv)) == 0;
  1579.     regs.v = (flgs != flgo) && (flgn != flgo);
  1580.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1581.     regs.n = flgn != 0;
  1582.     put_byte(dsta,newv);
  1583. }}}}}}}
  1584. void op_5320(UWORD opcode)
  1585. {
  1586.     ULONG srcreg = 1;
  1587.     ULONG dstreg = (opcode & 7) >> 0;
  1588. {{    ULONG src = srcreg;
  1589. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1590. {    CPTR dsta = regs.a[dstreg];
  1591.     BYTE dst = get_byte(dsta);
  1592. {    ULONG newv = dst - src;
  1593. {    bool flgs = ((BYTE)(src)) < 0;
  1594.     bool flgo = ((BYTE)(dst)) < 0;
  1595.     bool flgn = ((BYTE)(newv)) < 0;
  1596.     regs.z = ((BYTE)(newv)) == 0;
  1597.     regs.v = (flgs != flgo) && (flgn != flgo);
  1598.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1599.     regs.n = flgn != 0;
  1600.     put_byte(dsta,newv);
  1601. }}}}}}}
  1602. void op_5328(UWORD opcode)
  1603. {
  1604.     ULONG srcreg = 1;
  1605.     ULONG dstreg = (opcode & 7) >> 0;
  1606. {{    ULONG src = srcreg;
  1607. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1608.     BYTE dst = get_byte(dsta);
  1609. {    ULONG newv = dst - src;
  1610. {    bool flgs = ((BYTE)(src)) < 0;
  1611.     bool flgo = ((BYTE)(dst)) < 0;
  1612.     bool flgn = ((BYTE)(newv)) < 0;
  1613.     regs.z = ((BYTE)(newv)) == 0;
  1614.     regs.v = (flgs != flgo) && (flgn != flgo);
  1615.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1616.     regs.n = flgn != 0;
  1617.     put_byte(dsta,newv);
  1618. }}}}}}
  1619. void op_5330(UWORD opcode)
  1620. {
  1621.     ULONG srcreg = 1;
  1622.     ULONG dstreg = (opcode & 7) >> 0;
  1623. {{    ULONG src = srcreg;
  1624. {    CPTR dsta = regs.a[dstreg];
  1625.     UWORD dstdp = nextiword();
  1626.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1627. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1628.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1629.     dsta += dstdpr;
  1630. {    BYTE dst = get_byte(dsta);
  1631. {    ULONG newv = dst - src;
  1632. {    bool flgs = ((BYTE)(src)) < 0;
  1633.     bool flgo = ((BYTE)(dst)) < 0;
  1634.     bool flgn = ((BYTE)(newv)) < 0;
  1635.     regs.z = ((BYTE)(newv)) == 0;
  1636.     regs.v = (flgs != flgo) && (flgn != flgo);
  1637.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1638.     regs.n = flgn != 0;
  1639.     put_byte(dsta,newv);
  1640. }}}}}}}}
  1641. void op_5338(UWORD opcode)
  1642. {
  1643.     ULONG srcreg = 1;
  1644. {{    ULONG src = srcreg;
  1645. {    CPTR dsta = (LONG)(WORD)nextiword();
  1646.     BYTE dst = get_byte(dsta);
  1647. {    ULONG newv = dst - src;
  1648. {    bool flgs = ((BYTE)(src)) < 0;
  1649.     bool flgo = ((BYTE)(dst)) < 0;
  1650.     bool flgn = ((BYTE)(newv)) < 0;
  1651.     regs.z = ((BYTE)(newv)) == 0;
  1652.     regs.v = (flgs != flgo) && (flgn != flgo);
  1653.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1654.     regs.n = flgn != 0;
  1655.     put_byte(dsta,newv);
  1656. }}}}}}
  1657. void op_5339(UWORD opcode)
  1658. {
  1659.     ULONG srcreg = 1;
  1660. {{    ULONG src = srcreg;
  1661. {    CPTR dsta = nextilong();
  1662.     BYTE dst = get_byte(dsta);
  1663. {    ULONG newv = dst - src;
  1664. {    bool flgs = ((BYTE)(src)) < 0;
  1665.     bool flgo = ((BYTE)(dst)) < 0;
  1666.     bool flgn = ((BYTE)(newv)) < 0;
  1667.     regs.z = ((BYTE)(newv)) == 0;
  1668.     regs.v = (flgs != flgo) && (flgn != flgo);
  1669.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1670.     regs.n = flgn != 0;
  1671.     put_byte(dsta,newv);
  1672. }}}}}}
  1673. void op_5340(UWORD opcode)
  1674. {
  1675.     ULONG srcreg = 1;
  1676.     ULONG dstreg = (opcode & 7) >> 0;
  1677. {{    ULONG src = srcreg;
  1678. {    WORD dst = regs.d[dstreg];
  1679. {    ULONG newv = dst - src;
  1680. {    bool flgs = ((WORD)(src)) < 0;
  1681.     bool flgo = ((WORD)(dst)) < 0;
  1682.     bool flgn = ((WORD)(newv)) < 0;
  1683.     regs.z = ((WORD)(newv)) == 0;
  1684.     regs.v = (flgs != flgo) && (flgn != flgo);
  1685.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1686.     regs.n = flgn != 0;
  1687.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  1688. }}}}}}
  1689. void op_5348(UWORD opcode)
  1690. {
  1691.     ULONG srcreg = 1;
  1692.     ULONG dstreg = (opcode & 7) >> 0;
  1693. {{    ULONG src = srcreg;
  1694. {    LONG dst = regs.a[dstreg];
  1695. {    ULONG newv = dst - src;
  1696.     regs.a[dstreg] = (newv);
  1697. }}}}}
  1698. void op_5350(UWORD opcode)
  1699. {
  1700.     ULONG srcreg = 1;
  1701.     ULONG dstreg = (opcode & 7) >> 0;
  1702. {{    ULONG src = srcreg;
  1703. {    CPTR dsta = regs.a[dstreg];
  1704.     WORD dst = get_word(dsta);
  1705. {    ULONG newv = dst - src;
  1706. {    bool flgs = ((WORD)(src)) < 0;
  1707.     bool flgo = ((WORD)(dst)) < 0;
  1708.     bool flgn = ((WORD)(newv)) < 0;
  1709.     regs.z = ((WORD)(newv)) == 0;
  1710.     regs.v = (flgs != flgo) && (flgn != flgo);
  1711.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1712.     regs.n = flgn != 0;
  1713.     put_word(dsta,newv);
  1714. }}}}}}
  1715. void op_5358(UWORD opcode)
  1716. {
  1717.     ULONG srcreg = 1;
  1718.     ULONG dstreg = (opcode & 7) >> 0;
  1719. {{    ULONG src = srcreg;
  1720. {    CPTR dsta = regs.a[dstreg];
  1721.     WORD dst = get_word(dsta);
  1722. {    regs.a[dstreg] += 2;
  1723. {    ULONG newv = dst - src;
  1724. {    bool flgs = ((WORD)(src)) < 0;
  1725.     bool flgo = ((WORD)(dst)) < 0;
  1726.     bool flgn = ((WORD)(newv)) < 0;
  1727.     regs.z = ((WORD)(newv)) == 0;
  1728.     regs.v = (flgs != flgo) && (flgn != flgo);
  1729.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1730.     regs.n = flgn != 0;
  1731.     put_word(dsta,newv);
  1732. }}}}}}}
  1733. void op_5360(UWORD opcode)
  1734. {
  1735.     ULONG srcreg = 1;
  1736.     ULONG dstreg = (opcode & 7) >> 0;
  1737. {{    ULONG src = srcreg;
  1738. {    regs.a[dstreg] -= 2;
  1739. {    CPTR dsta = regs.a[dstreg];
  1740.     WORD dst = get_word(dsta);
  1741. {    ULONG newv = dst - src;
  1742. {    bool flgs = ((WORD)(src)) < 0;
  1743.     bool flgo = ((WORD)(dst)) < 0;
  1744.     bool flgn = ((WORD)(newv)) < 0;
  1745.     regs.z = ((WORD)(newv)) == 0;
  1746.     regs.v = (flgs != flgo) && (flgn != flgo);
  1747.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1748.     regs.n = flgn != 0;
  1749.     put_word(dsta,newv);
  1750. }}}}}}}
  1751. void op_5368(UWORD opcode)
  1752. {
  1753.     ULONG srcreg = 1;
  1754.     ULONG dstreg = (opcode & 7) >> 0;
  1755. {{    ULONG src = srcreg;
  1756. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1757.     WORD dst = get_word(dsta);
  1758. {    ULONG newv = dst - src;
  1759. {    bool flgs = ((WORD)(src)) < 0;
  1760.     bool flgo = ((WORD)(dst)) < 0;
  1761.     bool flgn = ((WORD)(newv)) < 0;
  1762.     regs.z = ((WORD)(newv)) == 0;
  1763.     regs.v = (flgs != flgo) && (flgn != flgo);
  1764.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1765.     regs.n = flgn != 0;
  1766.     put_word(dsta,newv);
  1767. }}}}}}
  1768. void op_5370(UWORD opcode)
  1769. {
  1770.     ULONG srcreg = 1;
  1771.     ULONG dstreg = (opcode & 7) >> 0;
  1772. {{    ULONG src = srcreg;
  1773. {    CPTR dsta = regs.a[dstreg];
  1774.     UWORD dstdp = nextiword();
  1775.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1776. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1777.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1778.     dsta += dstdpr;
  1779. {    WORD dst = get_word(dsta);
  1780. {    ULONG newv = dst - src;
  1781. {    bool flgs = ((WORD)(src)) < 0;
  1782.     bool flgo = ((WORD)(dst)) < 0;
  1783.     bool flgn = ((WORD)(newv)) < 0;
  1784.     regs.z = ((WORD)(newv)) == 0;
  1785.     regs.v = (flgs != flgo) && (flgn != flgo);
  1786.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1787.     regs.n = flgn != 0;
  1788.     put_word(dsta,newv);
  1789. }}}}}}}}
  1790. void op_5378(UWORD opcode)
  1791. {
  1792.     ULONG srcreg = 1;
  1793. {{    ULONG src = srcreg;
  1794. {    CPTR dsta = (LONG)(WORD)nextiword();
  1795.     WORD dst = get_word(dsta);
  1796. {    ULONG newv = dst - src;
  1797. {    bool flgs = ((WORD)(src)) < 0;
  1798.     bool flgo = ((WORD)(dst)) < 0;
  1799.     bool flgn = ((WORD)(newv)) < 0;
  1800.     regs.z = ((WORD)(newv)) == 0;
  1801.     regs.v = (flgs != flgo) && (flgn != flgo);
  1802.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1803.     regs.n = flgn != 0;
  1804.     put_word(dsta,newv);
  1805. }}}}}}
  1806. void op_5379(UWORD opcode)
  1807. {
  1808.     ULONG srcreg = 1;
  1809. {{    ULONG src = srcreg;
  1810. {    CPTR dsta = nextilong();
  1811.     WORD dst = get_word(dsta);
  1812. {    ULONG newv = dst - src;
  1813. {    bool flgs = ((WORD)(src)) < 0;
  1814.     bool flgo = ((WORD)(dst)) < 0;
  1815.     bool flgn = ((WORD)(newv)) < 0;
  1816.     regs.z = ((WORD)(newv)) == 0;
  1817.     regs.v = (flgs != flgo) && (flgn != flgo);
  1818.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1819.     regs.n = flgn != 0;
  1820.     put_word(dsta,newv);
  1821. }}}}}}
  1822. void op_5380(UWORD opcode)
  1823. {
  1824.     ULONG srcreg = 1;
  1825.     ULONG dstreg = (opcode & 7) >> 0;
  1826. {{    ULONG src = srcreg;
  1827. {    LONG dst = regs.d[dstreg];
  1828. {    ULONG newv = dst - src;
  1829. {    bool flgs = ((LONG)(src)) < 0;
  1830.     bool flgo = ((LONG)(dst)) < 0;
  1831.     bool flgn = ((LONG)(newv)) < 0;
  1832.     regs.z = ((LONG)(newv)) == 0;
  1833.     regs.v = (flgs != flgo) && (flgn != flgo);
  1834.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1835.     regs.n = flgn != 0;
  1836.     regs.d[dstreg] = (newv);
  1837. }}}}}}
  1838. void op_5388(UWORD opcode)
  1839. {
  1840.     ULONG srcreg = 1;
  1841.     ULONG dstreg = (opcode & 7) >> 0;
  1842. {{    ULONG src = srcreg;
  1843. {    LONG dst = regs.a[dstreg];
  1844. {    ULONG newv = dst - src;
  1845.     regs.a[dstreg] = (newv);
  1846. }}}}}
  1847. void op_5390(UWORD opcode)
  1848. {
  1849.     ULONG srcreg = 1;
  1850.     ULONG dstreg = (opcode & 7) >> 0;
  1851. {{    ULONG src = srcreg;
  1852. {    CPTR dsta = regs.a[dstreg];
  1853.     LONG dst = get_long(dsta);
  1854. {    ULONG newv = dst - src;
  1855. {    bool flgs = ((LONG)(src)) < 0;
  1856.     bool flgo = ((LONG)(dst)) < 0;
  1857.     bool flgn = ((LONG)(newv)) < 0;
  1858.     regs.z = ((LONG)(newv)) == 0;
  1859.     regs.v = (flgs != flgo) && (flgn != flgo);
  1860.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1861.     regs.n = flgn != 0;
  1862.     put_long(dsta,newv);
  1863. }}}}}}
  1864. void op_5398(UWORD opcode)
  1865. {
  1866.     ULONG srcreg = 1;
  1867.     ULONG dstreg = (opcode & 7) >> 0;
  1868. {{    ULONG src = srcreg;
  1869. {    CPTR dsta = regs.a[dstreg];
  1870.     LONG dst = get_long(dsta);
  1871. {    regs.a[dstreg] += 4;
  1872. {    ULONG newv = dst - src;
  1873. {    bool flgs = ((LONG)(src)) < 0;
  1874.     bool flgo = ((LONG)(dst)) < 0;
  1875.     bool flgn = ((LONG)(newv)) < 0;
  1876.     regs.z = ((LONG)(newv)) == 0;
  1877.     regs.v = (flgs != flgo) && (flgn != flgo);
  1878.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1879.     regs.n = flgn != 0;
  1880.     put_long(dsta,newv);
  1881. }}}}}}}
  1882. void op_53a0(UWORD opcode)
  1883. {
  1884.     ULONG srcreg = 1;
  1885.     ULONG dstreg = (opcode & 7) >> 0;
  1886. {{    ULONG src = srcreg;
  1887. {    regs.a[dstreg] -= 4;
  1888. {    CPTR dsta = regs.a[dstreg];
  1889.     LONG dst = get_long(dsta);
  1890. {    ULONG newv = dst - src;
  1891. {    bool flgs = ((LONG)(src)) < 0;
  1892.     bool flgo = ((LONG)(dst)) < 0;
  1893.     bool flgn = ((LONG)(newv)) < 0;
  1894.     regs.z = ((LONG)(newv)) == 0;
  1895.     regs.v = (flgs != flgo) && (flgn != flgo);
  1896.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1897.     regs.n = flgn != 0;
  1898.     put_long(dsta,newv);
  1899. }}}}}}}
  1900. void op_53a8(UWORD opcode)
  1901. {
  1902.     ULONG srcreg = 1;
  1903.     ULONG dstreg = (opcode & 7) >> 0;
  1904. {{    ULONG src = srcreg;
  1905. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1906.     LONG dst = get_long(dsta);
  1907. {    ULONG newv = dst - src;
  1908. {    bool flgs = ((LONG)(src)) < 0;
  1909.     bool flgo = ((LONG)(dst)) < 0;
  1910.     bool flgn = ((LONG)(newv)) < 0;
  1911.     regs.z = ((LONG)(newv)) == 0;
  1912.     regs.v = (flgs != flgo) && (flgn != flgo);
  1913.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1914.     regs.n = flgn != 0;
  1915.     put_long(dsta,newv);
  1916. }}}}}}
  1917. void op_53b0(UWORD opcode)
  1918. {
  1919.     ULONG srcreg = 1;
  1920.     ULONG dstreg = (opcode & 7) >> 0;
  1921. {{    ULONG src = srcreg;
  1922. {    CPTR dsta = regs.a[dstreg];
  1923.     UWORD dstdp = nextiword();
  1924.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1925. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1926.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1927.     dsta += dstdpr;
  1928. {    LONG dst = get_long(dsta);
  1929. {    ULONG newv = dst - src;
  1930. {    bool flgs = ((LONG)(src)) < 0;
  1931.     bool flgo = ((LONG)(dst)) < 0;
  1932.     bool flgn = ((LONG)(newv)) < 0;
  1933.     regs.z = ((LONG)(newv)) == 0;
  1934.     regs.v = (flgs != flgo) && (flgn != flgo);
  1935.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1936.     regs.n = flgn != 0;
  1937.     put_long(dsta,newv);
  1938. }}}}}}}}
  1939. void op_53b8(UWORD opcode)
  1940. {
  1941.     ULONG srcreg = 1;
  1942. {{    ULONG src = srcreg;
  1943. {    CPTR dsta = (LONG)(WORD)nextiword();
  1944.     LONG dst = get_long(dsta);
  1945. {    ULONG newv = dst - src;
  1946. {    bool flgs = ((LONG)(src)) < 0;
  1947.     bool flgo = ((LONG)(dst)) < 0;
  1948.     bool flgn = ((LONG)(newv)) < 0;
  1949.     regs.z = ((LONG)(newv)) == 0;
  1950.     regs.v = (flgs != flgo) && (flgn != flgo);
  1951.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1952.     regs.n = flgn != 0;
  1953.     put_long(dsta,newv);
  1954. }}}}}}
  1955. void op_53b9(UWORD opcode)
  1956. {
  1957.     ULONG srcreg = 1;
  1958. {{    ULONG src = srcreg;
  1959. {    CPTR dsta = nextilong();
  1960.     LONG dst = get_long(dsta);
  1961. {    ULONG newv = dst - src;
  1962. {    bool flgs = ((LONG)(src)) < 0;
  1963.     bool flgo = ((LONG)(dst)) < 0;
  1964.     bool flgn = ((LONG)(newv)) < 0;
  1965.     regs.z = ((LONG)(newv)) == 0;
  1966.     regs.v = (flgs != flgo) && (flgn != flgo);
  1967.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1968.     regs.n = flgn != 0;
  1969.     put_long(dsta,newv);
  1970. }}}}}}
  1971. void op_53c0(UWORD opcode)
  1972. {
  1973.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1974. {{{    int val = cctrue(3) ? 0xff : 0;
  1975.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  1976. }}}}
  1977. void op_53c8(UWORD opcode)
  1978. {
  1979.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1980. {{    WORD src = regs.d[srcreg];
  1981. {    WORD offs = nextiword();
  1982.     if (!cctrue(3)) {
  1983.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  1984.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  1985.     }
  1986. }}}}
  1987. void op_53d0(UWORD opcode)
  1988. {
  1989.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1990. {{    CPTR srca = regs.a[srcreg];
  1991. {    int val = cctrue(3) ? 0xff : 0;
  1992.     put_byte(srca,val);
  1993. }}}}
  1994. void op_53d8(UWORD opcode)
  1995. {
  1996.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1997. {{    CPTR srca = regs.a[srcreg];
  1998. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  1999. {    int val = cctrue(3) ? 0xff : 0;
  2000.     put_byte(srca,val);
  2001. }}}}}
  2002. void op_53e0(UWORD opcode)
  2003. {
  2004.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2005. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  2006. {    CPTR srca = regs.a[srcreg];
  2007. {    int val = cctrue(3) ? 0xff : 0;
  2008.     put_byte(srca,val);
  2009. }}}}}
  2010. void op_53e8(UWORD opcode)
  2011. {
  2012.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2013. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  2014. {    int val = cctrue(3) ? 0xff : 0;
  2015.     put_byte(srca,val);
  2016. }}}}
  2017. void op_53f0(UWORD opcode)
  2018. {
  2019.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2020. {{    CPTR srca = regs.a[srcreg];
  2021.     UWORD srcdp = nextiword();
  2022.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  2023. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  2024.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  2025.     srca += srcdpr;
  2026. {    int val = cctrue(3) ? 0xff : 0;
  2027.     put_byte(srca,val);
  2028. }}}}}
  2029. void op_53f8(UWORD opcode)
  2030. {
  2031. {{    CPTR srca = (LONG)(WORD)nextiword();
  2032. {    int val = cctrue(3) ? 0xff : 0;
  2033.     put_byte(srca,val);
  2034. }}}}
  2035. void op_53f9(UWORD opcode)
  2036. {
  2037. {{    CPTR srca = nextilong();
  2038. {    int val = cctrue(3) ? 0xff : 0;
  2039.     put_byte(srca,val);
  2040. }}}}
  2041. void op_5400(UWORD opcode)
  2042. {
  2043.     ULONG srcreg = 2;
  2044.     ULONG dstreg = (opcode & 7) >> 0;
  2045. {{    ULONG src = srcreg;
  2046. {    BYTE dst = regs.d[dstreg];
  2047. {    ULONG newv = dst + src;
  2048. {    bool flgs = ((BYTE)(src)) < 0;
  2049.     bool flgo = ((BYTE)(dst)) < 0;
  2050.     bool flgn = ((BYTE)(newv)) < 0;
  2051.     regs.z = ((BYTE)(newv)) == 0;
  2052.     regs.v = (flgs == flgo) && (flgn != flgo);
  2053.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2054.     regs.n = flgn != 0;
  2055.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  2056. }}}}}}
  2057. void op_5410(UWORD opcode)
  2058. {
  2059.     ULONG srcreg = 2;
  2060.     ULONG dstreg = (opcode & 7) >> 0;
  2061. {{    ULONG src = srcreg;
  2062. {    CPTR dsta = regs.a[dstreg];
  2063.     BYTE dst = get_byte(dsta);
  2064. {    ULONG newv = dst + src;
  2065. {    bool flgs = ((BYTE)(src)) < 0;
  2066.     bool flgo = ((BYTE)(dst)) < 0;
  2067.     bool flgn = ((BYTE)(newv)) < 0;
  2068.     regs.z = ((BYTE)(newv)) == 0;
  2069.     regs.v = (flgs == flgo) && (flgn != flgo);
  2070.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2071.     regs.n = flgn != 0;
  2072.     put_byte(dsta,newv);
  2073. }}}}}}
  2074. void op_5418(UWORD opcode)
  2075. {
  2076.     ULONG srcreg = 2;
  2077.     ULONG dstreg = (opcode & 7) >> 0;
  2078. {{    ULONG src = srcreg;
  2079. {    CPTR dsta = regs.a[dstreg];
  2080.     BYTE dst = get_byte(dsta);
  2081. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2082. {    ULONG newv = dst + src;
  2083. {    bool flgs = ((BYTE)(src)) < 0;
  2084.     bool flgo = ((BYTE)(dst)) < 0;
  2085.     bool flgn = ((BYTE)(newv)) < 0;
  2086.     regs.z = ((BYTE)(newv)) == 0;
  2087.     regs.v = (flgs == flgo) && (flgn != flgo);
  2088.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2089.     regs.n = flgn != 0;
  2090.     put_byte(dsta,newv);
  2091. }}}}}}}
  2092. void op_5420(UWORD opcode)
  2093. {
  2094.     ULONG srcreg = 2;
  2095.     ULONG dstreg = (opcode & 7) >> 0;
  2096. {{    ULONG src = srcreg;
  2097. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2098. {    CPTR dsta = regs.a[dstreg];
  2099.     BYTE dst = get_byte(dsta);
  2100. {    ULONG newv = dst + src;
  2101. {    bool flgs = ((BYTE)(src)) < 0;
  2102.     bool flgo = ((BYTE)(dst)) < 0;
  2103.     bool flgn = ((BYTE)(newv)) < 0;
  2104.     regs.z = ((BYTE)(newv)) == 0;
  2105.     regs.v = (flgs == flgo) && (flgn != flgo);
  2106.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2107.     regs.n = flgn != 0;
  2108.     put_byte(dsta,newv);
  2109. }}}}}}}
  2110. void op_5428(UWORD opcode)
  2111. {
  2112.     ULONG srcreg = 2;
  2113.     ULONG dstreg = (opcode & 7) >> 0;
  2114. {{    ULONG src = srcreg;
  2115. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2116.     BYTE dst = get_byte(dsta);
  2117. {    ULONG newv = dst + src;
  2118. {    bool flgs = ((BYTE)(src)) < 0;
  2119.     bool flgo = ((BYTE)(dst)) < 0;
  2120.     bool flgn = ((BYTE)(newv)) < 0;
  2121.     regs.z = ((BYTE)(newv)) == 0;
  2122.     regs.v = (flgs == flgo) && (flgn != flgo);
  2123.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2124.     regs.n = flgn != 0;
  2125.     put_byte(dsta,newv);
  2126. }}}}}}
  2127. void op_5430(UWORD opcode)
  2128. {
  2129.     ULONG srcreg = 2;
  2130.     ULONG dstreg = (opcode & 7) >> 0;
  2131. {{    ULONG src = srcreg;
  2132. {    CPTR dsta = regs.a[dstreg];
  2133.     UWORD dstdp = nextiword();
  2134.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2135. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2136.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2137.     dsta += dstdpr;
  2138. {    BYTE dst = get_byte(dsta);
  2139. {    ULONG newv = dst + src;
  2140. {    bool flgs = ((BYTE)(src)) < 0;
  2141.     bool flgo = ((BYTE)(dst)) < 0;
  2142.     bool flgn = ((BYTE)(newv)) < 0;
  2143.     regs.z = ((BYTE)(newv)) == 0;
  2144.     regs.v = (flgs == flgo) && (flgn != flgo);
  2145.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2146.     regs.n = flgn != 0;
  2147.     put_byte(dsta,newv);
  2148. }}}}}}}}
  2149. void op_5438(UWORD opcode)
  2150. {
  2151.     ULONG srcreg = 2;
  2152. {{    ULONG src = srcreg;
  2153. {    CPTR dsta = (LONG)(WORD)nextiword();
  2154.     BYTE dst = get_byte(dsta);
  2155. {    ULONG newv = dst + src;
  2156. {    bool flgs = ((BYTE)(src)) < 0;
  2157.     bool flgo = ((BYTE)(dst)) < 0;
  2158.     bool flgn = ((BYTE)(newv)) < 0;
  2159.     regs.z = ((BYTE)(newv)) == 0;
  2160.     regs.v = (flgs == flgo) && (flgn != flgo);
  2161.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2162.     regs.n = flgn != 0;
  2163.     put_byte(dsta,newv);
  2164. }}}}}}
  2165. void op_5439(UWORD opcode)
  2166. {
  2167.     ULONG srcreg = 2;
  2168. {{    ULONG src = srcreg;
  2169. {    CPTR dsta = nextilong();
  2170.     BYTE dst = get_byte(dsta);
  2171. {    ULONG newv = dst + src;
  2172. {    bool flgs = ((BYTE)(src)) < 0;
  2173.     bool flgo = ((BYTE)(dst)) < 0;
  2174.     bool flgn = ((BYTE)(newv)) < 0;
  2175.     regs.z = ((BYTE)(newv)) == 0;
  2176.     regs.v = (flgs == flgo) && (flgn != flgo);
  2177.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  2178.     regs.n = flgn != 0;
  2179.     put_byte(dsta,newv);
  2180. }}}}}}
  2181. void op_5440(UWORD opcode)
  2182. {
  2183.     ULONG srcreg = 2;
  2184.     ULONG dstreg = (opcode & 7) >> 0;
  2185. {{    ULONG src = srcreg;
  2186. {    WORD dst = regs.d[dstreg];
  2187. {    ULONG newv = dst + src;
  2188. {    bool flgs = ((WORD)(src)) < 0;
  2189.     bool flgo = ((WORD)(dst)) < 0;
  2190.     bool flgn = ((WORD)(newv)) < 0;
  2191.     regs.z = ((WORD)(newv)) == 0;
  2192.     regs.v = (flgs == flgo) && (flgn != flgo);
  2193.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2194.     regs.n = flgn != 0;
  2195.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  2196. }}}}}}
  2197. void op_5448(UWORD opcode)
  2198. {
  2199.     ULONG srcreg = 2;
  2200.     ULONG dstreg = (opcode & 7) >> 0;
  2201. {{    ULONG src = srcreg;
  2202. {    LONG dst = regs.a[dstreg];
  2203. {    ULONG newv = dst + src;
  2204.     regs.a[dstreg] = (newv);
  2205. }}}}}
  2206. void op_5450(UWORD opcode)
  2207. {
  2208.     ULONG srcreg = 2;
  2209.     ULONG dstreg = (opcode & 7) >> 0;
  2210. {{    ULONG src = srcreg;
  2211. {    CPTR dsta = regs.a[dstreg];
  2212.     WORD dst = get_word(dsta);
  2213. {    ULONG newv = dst + src;
  2214. {    bool flgs = ((WORD)(src)) < 0;
  2215.     bool flgo = ((WORD)(dst)) < 0;
  2216.     bool flgn = ((WORD)(newv)) < 0;
  2217.     regs.z = ((WORD)(newv)) == 0;
  2218.     regs.v = (flgs == flgo) && (flgn != flgo);
  2219.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2220.     regs.n = flgn != 0;
  2221.     put_word(dsta,newv);
  2222. }}}}}}
  2223. void op_5458(UWORD opcode)
  2224. {
  2225.     ULONG srcreg = 2;
  2226.     ULONG dstreg = (opcode & 7) >> 0;
  2227. {{    ULONG src = srcreg;
  2228. {    CPTR dsta = regs.a[dstreg];
  2229.     WORD dst = get_word(dsta);
  2230. {    regs.a[dstreg] += 2;
  2231. {    ULONG newv = dst + src;
  2232. {    bool flgs = ((WORD)(src)) < 0;
  2233.     bool flgo = ((WORD)(dst)) < 0;
  2234.     bool flgn = ((WORD)(newv)) < 0;
  2235.     regs.z = ((WORD)(newv)) == 0;
  2236.     regs.v = (flgs == flgo) && (flgn != flgo);
  2237.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2238.     regs.n = flgn != 0;
  2239.     put_word(dsta,newv);
  2240. }}}}}}}
  2241. void op_5460(UWORD opcode)
  2242. {
  2243.     ULONG srcreg = 2;
  2244.     ULONG dstreg = (opcode & 7) >> 0;
  2245. {{    ULONG src = srcreg;
  2246. {    regs.a[dstreg] -= 2;
  2247. {    CPTR dsta = regs.a[dstreg];
  2248.     WORD dst = get_word(dsta);
  2249. {    ULONG newv = dst + src;
  2250. {    bool flgs = ((WORD)(src)) < 0;
  2251.     bool flgo = ((WORD)(dst)) < 0;
  2252.     bool flgn = ((WORD)(newv)) < 0;
  2253.     regs.z = ((WORD)(newv)) == 0;
  2254.     regs.v = (flgs == flgo) && (flgn != flgo);
  2255.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2256.     regs.n = flgn != 0;
  2257.     put_word(dsta,newv);
  2258. }}}}}}}
  2259. void op_5468(UWORD opcode)
  2260. {
  2261.     ULONG srcreg = 2;
  2262.     ULONG dstreg = (opcode & 7) >> 0;
  2263. {{    ULONG src = srcreg;
  2264. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2265.     WORD dst = get_word(dsta);
  2266. {    ULONG newv = dst + src;
  2267. {    bool flgs = ((WORD)(src)) < 0;
  2268.     bool flgo = ((WORD)(dst)) < 0;
  2269.     bool flgn = ((WORD)(newv)) < 0;
  2270.     regs.z = ((WORD)(newv)) == 0;
  2271.     regs.v = (flgs == flgo) && (flgn != flgo);
  2272.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2273.     regs.n = flgn != 0;
  2274.     put_word(dsta,newv);
  2275. }}}}}}
  2276. void op_5470(UWORD opcode)
  2277. {
  2278.     ULONG srcreg = 2;
  2279.     ULONG dstreg = (opcode & 7) >> 0;
  2280. {{    ULONG src = srcreg;
  2281. {    CPTR dsta = regs.a[dstreg];
  2282.     UWORD dstdp = nextiword();
  2283.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2284. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2285.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2286.     dsta += dstdpr;
  2287. {    WORD dst = get_word(dsta);
  2288. {    ULONG newv = dst + src;
  2289. {    bool flgs = ((WORD)(src)) < 0;
  2290.     bool flgo = ((WORD)(dst)) < 0;
  2291.     bool flgn = ((WORD)(newv)) < 0;
  2292.     regs.z = ((WORD)(newv)) == 0;
  2293.     regs.v = (flgs == flgo) && (flgn != flgo);
  2294.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2295.     regs.n = flgn != 0;
  2296.     put_word(dsta,newv);
  2297. }}}}}}}}
  2298. void op_5478(UWORD opcode)
  2299. {
  2300.     ULONG srcreg = 2;
  2301. {{    ULONG src = srcreg;
  2302. {    CPTR dsta = (LONG)(WORD)nextiword();
  2303.     WORD dst = get_word(dsta);
  2304. {    ULONG newv = dst + src;
  2305. {    bool flgs = ((WORD)(src)) < 0;
  2306.     bool flgo = ((WORD)(dst)) < 0;
  2307.     bool flgn = ((WORD)(newv)) < 0;
  2308.     regs.z = ((WORD)(newv)) == 0;
  2309.     regs.v = (flgs == flgo) && (flgn != flgo);
  2310.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2311.     regs.n = flgn != 0;
  2312.     put_word(dsta,newv);
  2313. }}}}}}
  2314. void op_5479(UWORD opcode)
  2315. {
  2316.     ULONG srcreg = 2;
  2317. {{    ULONG src = srcreg;
  2318. {    CPTR dsta = nextilong();
  2319.     WORD dst = get_word(dsta);
  2320. {    ULONG newv = dst + src;
  2321. {    bool flgs = ((WORD)(src)) < 0;
  2322.     bool flgo = ((WORD)(dst)) < 0;
  2323.     bool flgn = ((WORD)(newv)) < 0;
  2324.     regs.z = ((WORD)(newv)) == 0;
  2325.     regs.v = (flgs == flgo) && (flgn != flgo);
  2326.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  2327.     regs.n = flgn != 0;
  2328.     put_word(dsta,newv);
  2329. }}}}}}
  2330. void op_5480(UWORD opcode)
  2331. {
  2332.     ULONG srcreg = 2;
  2333.     ULONG dstreg = (opcode & 7) >> 0;
  2334. {{    ULONG src = srcreg;
  2335. {    LONG dst = regs.d[dstreg];
  2336. {    ULONG newv = dst + src;
  2337. {    bool flgs = ((LONG)(src)) < 0;
  2338.     bool flgo = ((LONG)(dst)) < 0;
  2339.     bool flgn = ((LONG)(newv)) < 0;
  2340.     regs.z = ((LONG)(newv)) == 0;
  2341.     regs.v = (flgs == flgo) && (flgn != flgo);
  2342.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2343.     regs.n = flgn != 0;
  2344.     regs.d[dstreg] = (newv);
  2345. }}}}}}
  2346. void op_5488(UWORD opcode)
  2347. {
  2348.     ULONG srcreg = 2;
  2349.     ULONG dstreg = (opcode & 7) >> 0;
  2350. {{    ULONG src = srcreg;
  2351. {    LONG dst = regs.a[dstreg];
  2352. {    ULONG newv = dst + src;
  2353.     regs.a[dstreg] = (newv);
  2354. }}}}}
  2355. void op_5490(UWORD opcode)
  2356. {
  2357.     ULONG srcreg = 2;
  2358.     ULONG dstreg = (opcode & 7) >> 0;
  2359. {{    ULONG src = srcreg;
  2360. {    CPTR dsta = regs.a[dstreg];
  2361.     LONG dst = get_long(dsta);
  2362. {    ULONG newv = dst + src;
  2363. {    bool flgs = ((LONG)(src)) < 0;
  2364.     bool flgo = ((LONG)(dst)) < 0;
  2365.     bool flgn = ((LONG)(newv)) < 0;
  2366.     regs.z = ((LONG)(newv)) == 0;
  2367.     regs.v = (flgs == flgo) && (flgn != flgo);
  2368.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2369.     regs.n = flgn != 0;
  2370.     put_long(dsta,newv);
  2371. }}}}}}
  2372. void op_5498(UWORD opcode)
  2373. {
  2374.     ULONG srcreg = 2;
  2375.     ULONG dstreg = (opcode & 7) >> 0;
  2376. {{    ULONG src = srcreg;
  2377. {    CPTR dsta = regs.a[dstreg];
  2378.     LONG dst = get_long(dsta);
  2379. {    regs.a[dstreg] += 4;
  2380. {    ULONG newv = dst + src;
  2381. {    bool flgs = ((LONG)(src)) < 0;
  2382.     bool flgo = ((LONG)(dst)) < 0;
  2383.     bool flgn = ((LONG)(newv)) < 0;
  2384.     regs.z = ((LONG)(newv)) == 0;
  2385.     regs.v = (flgs == flgo) && (flgn != flgo);
  2386.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2387.     regs.n = flgn != 0;
  2388.     put_long(dsta,newv);
  2389. }}}}}}}
  2390. void op_54a0(UWORD opcode)
  2391. {
  2392.     ULONG srcreg = 2;
  2393.     ULONG dstreg = (opcode & 7) >> 0;
  2394. {{    ULONG src = srcreg;
  2395. {    regs.a[dstreg] -= 4;
  2396. {    CPTR dsta = regs.a[dstreg];
  2397.     LONG dst = get_long(dsta);
  2398. {    ULONG newv = dst + src;
  2399. {    bool flgs = ((LONG)(src)) < 0;
  2400.     bool flgo = ((LONG)(dst)) < 0;
  2401.     bool flgn = ((LONG)(newv)) < 0;
  2402.     regs.z = ((LONG)(newv)) == 0;
  2403.     regs.v = (flgs == flgo) && (flgn != flgo);
  2404.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2405.     regs.n = flgn != 0;
  2406.     put_long(dsta,newv);
  2407. }}}}}}}
  2408. void op_54a8(UWORD opcode)
  2409. {
  2410.     ULONG srcreg = 2;
  2411.     ULONG dstreg = (opcode & 7) >> 0;
  2412. {{    ULONG src = srcreg;
  2413. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2414.     LONG dst = get_long(dsta);
  2415. {    ULONG newv = dst + src;
  2416. {    bool flgs = ((LONG)(src)) < 0;
  2417.     bool flgo = ((LONG)(dst)) < 0;
  2418.     bool flgn = ((LONG)(newv)) < 0;
  2419.     regs.z = ((LONG)(newv)) == 0;
  2420.     regs.v = (flgs == flgo) && (flgn != flgo);
  2421.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2422.     regs.n = flgn != 0;
  2423.     put_long(dsta,newv);
  2424. }}}}}}
  2425. void op_54b0(UWORD opcode)
  2426. {
  2427.     ULONG srcreg = 2;
  2428.     ULONG dstreg = (opcode & 7) >> 0;
  2429. {{    ULONG src = srcreg;
  2430. {    CPTR dsta = regs.a[dstreg];
  2431.     UWORD dstdp = nextiword();
  2432.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2433. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2434.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2435.     dsta += dstdpr;
  2436. {    LONG dst = get_long(dsta);
  2437. {    ULONG newv = dst + src;
  2438. {    bool flgs = ((LONG)(src)) < 0;
  2439.     bool flgo = ((LONG)(dst)) < 0;
  2440.     bool flgn = ((LONG)(newv)) < 0;
  2441.     regs.z = ((LONG)(newv)) == 0;
  2442.     regs.v = (flgs == flgo) && (flgn != flgo);
  2443.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2444.     regs.n = flgn != 0;
  2445.     put_long(dsta,newv);
  2446. }}}}}}}}
  2447. void op_54b8(UWORD opcode)
  2448. {
  2449.     ULONG srcreg = 2;
  2450. {{    ULONG src = srcreg;
  2451. {    CPTR dsta = (LONG)(WORD)nextiword();
  2452.     LONG dst = get_long(dsta);
  2453. {    ULONG newv = dst + src;
  2454. {    bool flgs = ((LONG)(src)) < 0;
  2455.     bool flgo = ((LONG)(dst)) < 0;
  2456.     bool flgn = ((LONG)(newv)) < 0;
  2457.     regs.z = ((LONG)(newv)) == 0;
  2458.     regs.v = (flgs == flgo) && (flgn != flgo);
  2459.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2460.     regs.n = flgn != 0;
  2461.     put_long(dsta,newv);
  2462. }}}}}}
  2463. void op_54b9(UWORD opcode)
  2464. {
  2465.     ULONG srcreg = 2;
  2466. {{    ULONG src = srcreg;
  2467. {    CPTR dsta = nextilong();
  2468.     LONG dst = get_long(dsta);
  2469. {    ULONG newv = dst + src;
  2470. {    bool flgs = ((LONG)(src)) < 0;
  2471.     bool flgo = ((LONG)(dst)) < 0;
  2472.     bool flgn = ((LONG)(newv)) < 0;
  2473.     regs.z = ((LONG)(newv)) == 0;
  2474.     regs.v = (flgs == flgo) && (flgn != flgo);
  2475.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  2476.     regs.n = flgn != 0;
  2477.     put_long(dsta,newv);
  2478. }}}}}}
  2479. void op_54c0(UWORD opcode)
  2480. {
  2481.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2482. {{{    int val = cctrue(4) ? 0xff : 0;
  2483.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  2484. }}}}
  2485. void op_54c8(UWORD opcode)
  2486. {
  2487.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2488. {{    WORD src = regs.d[srcreg];
  2489. {    WORD offs = nextiword();
  2490.     if (!cctrue(4)) {
  2491.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  2492.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  2493.     }
  2494. }}}}
  2495. void op_54d0(UWORD opcode)
  2496. {
  2497.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2498. {{    CPTR srca = regs.a[srcreg];
  2499. {    int val = cctrue(4) ? 0xff : 0;
  2500.     put_byte(srca,val);
  2501. }}}}
  2502. void op_54d8(UWORD opcode)
  2503. {
  2504.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2505. {{    CPTR srca = regs.a[srcreg];
  2506. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  2507. {    int val = cctrue(4) ? 0xff : 0;
  2508.     put_byte(srca,val);
  2509. }}}}}
  2510. void op_54e0(UWORD opcode)
  2511. {
  2512.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2513. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  2514. {    CPTR srca = regs.a[srcreg];
  2515. {    int val = cctrue(4) ? 0xff : 0;
  2516.     put_byte(srca,val);
  2517. }}}}}
  2518. void op_54e8(UWORD opcode)
  2519. {
  2520.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2521. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  2522. {    int val = cctrue(4) ? 0xff : 0;
  2523.     put_byte(srca,val);
  2524. }}}}
  2525. void op_54f0(UWORD opcode)
  2526. {
  2527.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2528. {{    CPTR srca = regs.a[srcreg];
  2529.     UWORD srcdp = nextiword();
  2530.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  2531. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  2532.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  2533.     srca += srcdpr;
  2534. {    int val = cctrue(4) ? 0xff : 0;
  2535.     put_byte(srca,val);
  2536. }}}}}
  2537. void op_54f8(UWORD opcode)
  2538. {
  2539. {{    CPTR srca = (LONG)(WORD)nextiword();
  2540. {    int val = cctrue(4) ? 0xff : 0;
  2541.     put_byte(srca,val);
  2542. }}}}
  2543. void op_54f9(UWORD opcode)
  2544. {
  2545. {{    CPTR srca = nextilong();
  2546. {    int val = cctrue(4) ? 0xff : 0;
  2547.     put_byte(srca,val);
  2548. }}}}
  2549. void op_5500(UWORD opcode)
  2550. {
  2551.     ULONG srcreg = 2;
  2552.     ULONG dstreg = (opcode & 7) >> 0;
  2553. {{    ULONG src = srcreg;
  2554. {    BYTE dst = regs.d[dstreg];
  2555. {    ULONG newv = dst - src;
  2556. {    bool flgs = ((BYTE)(src)) < 0;
  2557.     bool flgo = ((BYTE)(dst)) < 0;
  2558.     bool flgn = ((BYTE)(newv)) < 0;
  2559.     regs.z = ((BYTE)(newv)) == 0;
  2560.     regs.v = (flgs != flgo) && (flgn != flgo);
  2561.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2562.     regs.n = flgn != 0;
  2563.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  2564. }}}}}}
  2565. void op_5510(UWORD opcode)
  2566. {
  2567.     ULONG srcreg = 2;
  2568.     ULONG dstreg = (opcode & 7) >> 0;
  2569. {{    ULONG src = srcreg;
  2570. {    CPTR dsta = regs.a[dstreg];
  2571.     BYTE dst = get_byte(dsta);
  2572. {    ULONG newv = dst - src;
  2573. {    bool flgs = ((BYTE)(src)) < 0;
  2574.     bool flgo = ((BYTE)(dst)) < 0;
  2575.     bool flgn = ((BYTE)(newv)) < 0;
  2576.     regs.z = ((BYTE)(newv)) == 0;
  2577.     regs.v = (flgs != flgo) && (flgn != flgo);
  2578.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2579.     regs.n = flgn != 0;
  2580.     put_byte(dsta,newv);
  2581. }}}}}}
  2582. void op_5518(UWORD opcode)
  2583. {
  2584.     ULONG srcreg = 2;
  2585.     ULONG dstreg = (opcode & 7) >> 0;
  2586. {{    ULONG src = srcreg;
  2587. {    CPTR dsta = regs.a[dstreg];
  2588.     BYTE dst = get_byte(dsta);
  2589. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2590. {    ULONG newv = dst - src;
  2591. {    bool flgs = ((BYTE)(src)) < 0;
  2592.     bool flgo = ((BYTE)(dst)) < 0;
  2593.     bool flgn = ((BYTE)(newv)) < 0;
  2594.     regs.z = ((BYTE)(newv)) == 0;
  2595.     regs.v = (flgs != flgo) && (flgn != flgo);
  2596.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2597.     regs.n = flgn != 0;
  2598.     put_byte(dsta,newv);
  2599. }}}}}}}
  2600. void op_5520(UWORD opcode)
  2601. {
  2602.     ULONG srcreg = 2;
  2603.     ULONG dstreg = (opcode & 7) >> 0;
  2604. {{    ULONG src = srcreg;
  2605. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2606. {    CPTR dsta = regs.a[dstreg];
  2607.     BYTE dst = get_byte(dsta);
  2608. {    ULONG newv = dst - src;
  2609. {    bool flgs = ((BYTE)(src)) < 0;
  2610.     bool flgo = ((BYTE)(dst)) < 0;
  2611.     bool flgn = ((BYTE)(newv)) < 0;
  2612.     regs.z = ((BYTE)(newv)) == 0;
  2613.     regs.v = (flgs != flgo) && (flgn != flgo);
  2614.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2615.     regs.n = flgn != 0;
  2616.     put_byte(dsta,newv);
  2617. }}}}}}}
  2618. void op_5528(UWORD opcode)
  2619. {
  2620.     ULONG srcreg = 2;
  2621.     ULONG dstreg = (opcode & 7) >> 0;
  2622. {{    ULONG src = srcreg;
  2623. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2624.     BYTE dst = get_byte(dsta);
  2625. {    ULONG newv = dst - src;
  2626. {    bool flgs = ((BYTE)(src)) < 0;
  2627.     bool flgo = ((BYTE)(dst)) < 0;
  2628.     bool flgn = ((BYTE)(newv)) < 0;
  2629.     regs.z = ((BYTE)(newv)) == 0;
  2630.     regs.v = (flgs != flgo) && (flgn != flgo);
  2631.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2632.     regs.n = flgn != 0;
  2633.     put_byte(dsta,newv);
  2634. }}}}}}
  2635. void op_5530(UWORD opcode)
  2636. {
  2637.     ULONG srcreg = 2;
  2638.     ULONG dstreg = (opcode & 7) >> 0;
  2639. {{    ULONG src = srcreg;
  2640. {    CPTR dsta = regs.a[dstreg];
  2641.     UWORD dstdp = nextiword();
  2642.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2643. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2644.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2645.     dsta += dstdpr;
  2646. {    BYTE dst = get_byte(dsta);
  2647. {    ULONG newv = dst - src;
  2648. {    bool flgs = ((BYTE)(src)) < 0;
  2649.     bool flgo = ((BYTE)(dst)) < 0;
  2650.     bool flgn = ((BYTE)(newv)) < 0;
  2651.     regs.z = ((BYTE)(newv)) == 0;
  2652.     regs.v = (flgs != flgo) && (flgn != flgo);
  2653.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2654.     regs.n = flgn != 0;
  2655.     put_byte(dsta,newv);
  2656. }}}}}}}}
  2657. void op_5538(UWORD opcode)
  2658. {
  2659.     ULONG srcreg = 2;
  2660. {{    ULONG src = srcreg;
  2661. {    CPTR dsta = (LONG)(WORD)nextiword();
  2662.     BYTE dst = get_byte(dsta);
  2663. {    ULONG newv = dst - src;
  2664. {    bool flgs = ((BYTE)(src)) < 0;
  2665.     bool flgo = ((BYTE)(dst)) < 0;
  2666.     bool flgn = ((BYTE)(newv)) < 0;
  2667.     regs.z = ((BYTE)(newv)) == 0;
  2668.     regs.v = (flgs != flgo) && (flgn != flgo);
  2669.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2670.     regs.n = flgn != 0;
  2671.     put_byte(dsta,newv);
  2672. }}}}}}
  2673. void op_5539(UWORD opcode)
  2674. {
  2675.     ULONG srcreg = 2;
  2676. {{    ULONG src = srcreg;
  2677. {    CPTR dsta = nextilong();
  2678.     BYTE dst = get_byte(dsta);
  2679. {    ULONG newv = dst - src;
  2680. {    bool flgs = ((BYTE)(src)) < 0;
  2681.     bool flgo = ((BYTE)(dst)) < 0;
  2682.     bool flgn = ((BYTE)(newv)) < 0;
  2683.     regs.z = ((BYTE)(newv)) == 0;
  2684.     regs.v = (flgs != flgo) && (flgn != flgo);
  2685.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  2686.     regs.n = flgn != 0;
  2687.     put_byte(dsta,newv);
  2688. }}}}}}
  2689. void op_5540(UWORD opcode)
  2690. {
  2691.     ULONG srcreg = 2;
  2692.     ULONG dstreg = (opcode & 7) >> 0;
  2693. {{    ULONG src = srcreg;
  2694. {    WORD dst = regs.d[dstreg];
  2695. {    ULONG newv = dst - src;
  2696. {    bool flgs = ((WORD)(src)) < 0;
  2697.     bool flgo = ((WORD)(dst)) < 0;
  2698.     bool flgn = ((WORD)(newv)) < 0;
  2699.     regs.z = ((WORD)(newv)) == 0;
  2700.     regs.v = (flgs != flgo) && (flgn != flgo);
  2701.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2702.     regs.n = flgn != 0;
  2703.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  2704. }}}}}}
  2705. void op_5548(UWORD opcode)
  2706. {
  2707.     ULONG srcreg = 2;
  2708.     ULONG dstreg = (opcode & 7) >> 0;
  2709. {{    ULONG src = srcreg;
  2710. {    LONG dst = regs.a[dstreg];
  2711. {    ULONG newv = dst - src;
  2712.     regs.a[dstreg] = (newv);
  2713. }}}}}
  2714. void op_5550(UWORD opcode)
  2715. {
  2716.     ULONG srcreg = 2;
  2717.     ULONG dstreg = (opcode & 7) >> 0;
  2718. {{    ULONG src = srcreg;
  2719. {    CPTR dsta = regs.a[dstreg];
  2720.     WORD dst = get_word(dsta);
  2721. {    ULONG newv = dst - src;
  2722. {    bool flgs = ((WORD)(src)) < 0;
  2723.     bool flgo = ((WORD)(dst)) < 0;
  2724.     bool flgn = ((WORD)(newv)) < 0;
  2725.     regs.z = ((WORD)(newv)) == 0;
  2726.     regs.v = (flgs != flgo) && (flgn != flgo);
  2727.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2728.     regs.n = flgn != 0;
  2729.     put_word(dsta,newv);
  2730. }}}}}}
  2731. void op_5558(UWORD opcode)
  2732. {
  2733.     ULONG srcreg = 2;
  2734.     ULONG dstreg = (opcode & 7) >> 0;
  2735. {{    ULONG src = srcreg;
  2736. {    CPTR dsta = regs.a[dstreg];
  2737.     WORD dst = get_word(dsta);
  2738. {    regs.a[dstreg] += 2;
  2739. {    ULONG newv = dst - src;
  2740. {    bool flgs = ((WORD)(src)) < 0;
  2741.     bool flgo = ((WORD)(dst)) < 0;
  2742.     bool flgn = ((WORD)(newv)) < 0;
  2743.     regs.z = ((WORD)(newv)) == 0;
  2744.     regs.v = (flgs != flgo) && (flgn != flgo);
  2745.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2746.     regs.n = flgn != 0;
  2747.     put_word(dsta,newv);
  2748. }}}}}}}
  2749. void op_5560(UWORD opcode)
  2750. {
  2751.     ULONG srcreg = 2;
  2752.     ULONG dstreg = (opcode & 7) >> 0;
  2753. {{    ULONG src = srcreg;
  2754. {    regs.a[dstreg] -= 2;
  2755. {    CPTR dsta = regs.a[dstreg];
  2756.     WORD dst = get_word(dsta);
  2757. {    ULONG newv = dst - src;
  2758. {    bool flgs = ((WORD)(src)) < 0;
  2759.     bool flgo = ((WORD)(dst)) < 0;
  2760.     bool flgn = ((WORD)(newv)) < 0;
  2761.     regs.z = ((WORD)(newv)) == 0;
  2762.     regs.v = (flgs != flgo) && (flgn != flgo);
  2763.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2764.     regs.n = flgn != 0;
  2765.     put_word(dsta,newv);
  2766. }}}}}}}
  2767. void op_5568(UWORD opcode)
  2768. {
  2769.     ULONG srcreg = 2;
  2770.     ULONG dstreg = (opcode & 7) >> 0;
  2771. {{    ULONG src = srcreg;
  2772. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2773.     WORD dst = get_word(dsta);
  2774. {    ULONG newv = dst - src;
  2775. {    bool flgs = ((WORD)(src)) < 0;
  2776.     bool flgo = ((WORD)(dst)) < 0;
  2777.     bool flgn = ((WORD)(newv)) < 0;
  2778.     regs.z = ((WORD)(newv)) == 0;
  2779.     regs.v = (flgs != flgo) && (flgn != flgo);
  2780.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2781.     regs.n = flgn != 0;
  2782.     put_word(dsta,newv);
  2783. }}}}}}
  2784. void op_5570(UWORD opcode)
  2785. {
  2786.     ULONG srcreg = 2;
  2787.     ULONG dstreg = (opcode & 7) >> 0;
  2788. {{    ULONG src = srcreg;
  2789. {    CPTR dsta = regs.a[dstreg];
  2790.     UWORD dstdp = nextiword();
  2791.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2792. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2793.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2794.     dsta += dstdpr;
  2795. {    WORD dst = get_word(dsta);
  2796. {    ULONG newv = dst - src;
  2797. {    bool flgs = ((WORD)(src)) < 0;
  2798.     bool flgo = ((WORD)(dst)) < 0;
  2799.     bool flgn = ((WORD)(newv)) < 0;
  2800.     regs.z = ((WORD)(newv)) == 0;
  2801.     regs.v = (flgs != flgo) && (flgn != flgo);
  2802.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2803.     regs.n = flgn != 0;
  2804.     put_word(dsta,newv);
  2805. }}}}}}}}
  2806. void op_5578(UWORD opcode)
  2807. {
  2808.     ULONG srcreg = 2;
  2809. {{    ULONG src = srcreg;
  2810. {    CPTR dsta = (LONG)(WORD)nextiword();
  2811.     WORD dst = get_word(dsta);
  2812. {    ULONG newv = dst - src;
  2813. {    bool flgs = ((WORD)(src)) < 0;
  2814.     bool flgo = ((WORD)(dst)) < 0;
  2815.     bool flgn = ((WORD)(newv)) < 0;
  2816.     regs.z = ((WORD)(newv)) == 0;
  2817.     regs.v = (flgs != flgo) && (flgn != flgo);
  2818.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2819.     regs.n = flgn != 0;
  2820.     put_word(dsta,newv);
  2821. }}}}}}
  2822. void op_5579(UWORD opcode)
  2823. {
  2824.     ULONG srcreg = 2;
  2825. {{    ULONG src = srcreg;
  2826. {    CPTR dsta = nextilong();
  2827.     WORD dst = get_word(dsta);
  2828. {    ULONG newv = dst - src;
  2829. {    bool flgs = ((WORD)(src)) < 0;
  2830.     bool flgo = ((WORD)(dst)) < 0;
  2831.     bool flgn = ((WORD)(newv)) < 0;
  2832.     regs.z = ((WORD)(newv)) == 0;
  2833.     regs.v = (flgs != flgo) && (flgn != flgo);
  2834.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  2835.     regs.n = flgn != 0;
  2836.     put_word(dsta,newv);
  2837. }}}}}}
  2838. void op_5580(UWORD opcode)
  2839. {
  2840.     ULONG srcreg = 2;
  2841.     ULONG dstreg = (opcode & 7) >> 0;
  2842. {{    ULONG src = srcreg;
  2843. {    LONG dst = regs.d[dstreg];
  2844. {    ULONG newv = dst - src;
  2845. {    bool flgs = ((LONG)(src)) < 0;
  2846.     bool flgo = ((LONG)(dst)) < 0;
  2847.     bool flgn = ((LONG)(newv)) < 0;
  2848.     regs.z = ((LONG)(newv)) == 0;
  2849.     regs.v = (flgs != flgo) && (flgn != flgo);
  2850.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2851.     regs.n = flgn != 0;
  2852.     regs.d[dstreg] = (newv);
  2853. }}}}}}
  2854. void op_5588(UWORD opcode)
  2855. {
  2856.     ULONG srcreg = 2;
  2857.     ULONG dstreg = (opcode & 7) >> 0;
  2858. {{    ULONG src = srcreg;
  2859. {    LONG dst = regs.a[dstreg];
  2860. {    ULONG newv = dst - src;
  2861.     regs.a[dstreg] = (newv);
  2862. }}}}}
  2863. void op_5590(UWORD opcode)
  2864. {
  2865.     ULONG srcreg = 2;
  2866.     ULONG dstreg = (opcode & 7) >> 0;
  2867. {{    ULONG src = srcreg;
  2868. {    CPTR dsta = regs.a[dstreg];
  2869.     LONG dst = get_long(dsta);
  2870. {    ULONG newv = dst - src;
  2871. {    bool flgs = ((LONG)(src)) < 0;
  2872.     bool flgo = ((LONG)(dst)) < 0;
  2873.     bool flgn = ((LONG)(newv)) < 0;
  2874.     regs.z = ((LONG)(newv)) == 0;
  2875.     regs.v = (flgs != flgo) && (flgn != flgo);
  2876.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2877.     regs.n = flgn != 0;
  2878.     put_long(dsta,newv);
  2879. }}}}}}
  2880. void op_5598(UWORD opcode)
  2881. {
  2882.     ULONG srcreg = 2;
  2883.     ULONG dstreg = (opcode & 7) >> 0;
  2884. {{    ULONG src = srcreg;
  2885. {    CPTR dsta = regs.a[dstreg];
  2886.     LONG dst = get_long(dsta);
  2887. {    regs.a[dstreg] += 4;
  2888. {    ULONG newv = dst - src;
  2889. {    bool flgs = ((LONG)(src)) < 0;
  2890.     bool flgo = ((LONG)(dst)) < 0;
  2891.     bool flgn = ((LONG)(newv)) < 0;
  2892.     regs.z = ((LONG)(newv)) == 0;
  2893.     regs.v = (flgs != flgo) && (flgn != flgo);
  2894.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2895.     regs.n = flgn != 0;
  2896.     put_long(dsta,newv);
  2897. }}}}}}}
  2898. void op_55a0(UWORD opcode)
  2899. {
  2900.     ULONG srcreg = 2;
  2901.     ULONG dstreg = (opcode & 7) >> 0;
  2902. {{    ULONG src = srcreg;
  2903. {    regs.a[dstreg] -= 4;
  2904. {    CPTR dsta = regs.a[dstreg];
  2905.     LONG dst = get_long(dsta);
  2906. {    ULONG newv = dst - src;
  2907. {    bool flgs = ((LONG)(src)) < 0;
  2908.     bool flgo = ((LONG)(dst)) < 0;
  2909.     bool flgn = ((LONG)(newv)) < 0;
  2910.     regs.z = ((LONG)(newv)) == 0;
  2911.     regs.v = (flgs != flgo) && (flgn != flgo);
  2912.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2913.     regs.n = flgn != 0;
  2914.     put_long(dsta,newv);
  2915. }}}}}}}
  2916. void op_55a8(UWORD opcode)
  2917. {
  2918.     ULONG srcreg = 2;
  2919.     ULONG dstreg = (opcode & 7) >> 0;
  2920. {{    ULONG src = srcreg;
  2921. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2922.     LONG dst = get_long(dsta);
  2923. {    ULONG newv = dst - src;
  2924. {    bool flgs = ((LONG)(src)) < 0;
  2925.     bool flgo = ((LONG)(dst)) < 0;
  2926.     bool flgn = ((LONG)(newv)) < 0;
  2927.     regs.z = ((LONG)(newv)) == 0;
  2928.     regs.v = (flgs != flgo) && (flgn != flgo);
  2929.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2930.     regs.n = flgn != 0;
  2931.     put_long(dsta,newv);
  2932. }}}}}}
  2933. void op_55b0(UWORD opcode)
  2934. {
  2935.     ULONG srcreg = 2;
  2936.     ULONG dstreg = (opcode & 7) >> 0;
  2937. {{    ULONG src = srcreg;
  2938. {    CPTR dsta = regs.a[dstreg];
  2939.     UWORD dstdp = nextiword();
  2940.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2941. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2942.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2943.     dsta += dstdpr;
  2944. {    LONG dst = get_long(dsta);
  2945. {    ULONG newv = dst - src;
  2946. {    bool flgs = ((LONG)(src)) < 0;
  2947.     bool flgo = ((LONG)(dst)) < 0;
  2948.     bool flgn = ((LONG)(newv)) < 0;
  2949.     regs.z = ((LONG)(newv)) == 0;
  2950.     regs.v = (flgs != flgo) && (flgn != flgo);
  2951.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2952.     regs.n = flgn != 0;
  2953.     put_long(dsta,newv);
  2954. }}}}}}}}
  2955. void op_55b8(UWORD opcode)
  2956. {
  2957.     ULONG srcreg = 2;
  2958. {{    ULONG src = srcreg;
  2959. {    CPTR dsta = (LONG)(WORD)nextiword();
  2960.     LONG dst = get_long(dsta);
  2961. {    ULONG newv = dst - src;
  2962. {    bool flgs = ((LONG)(src)) < 0;
  2963.     bool flgo = ((LONG)(dst)) < 0;
  2964.     bool flgn = ((LONG)(newv)) < 0;
  2965.     regs.z = ((LONG)(newv)) == 0;
  2966.     regs.v = (flgs != flgo) && (flgn != flgo);
  2967.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2968.     regs.n = flgn != 0;
  2969.     put_long(dsta,newv);
  2970. }}}}}}
  2971. void op_55b9(UWORD opcode)
  2972. {
  2973.     ULONG srcreg = 2;
  2974. {{    ULONG src = srcreg;
  2975. {    CPTR dsta = nextilong();
  2976.     LONG dst = get_long(dsta);
  2977. {    ULONG newv = dst - src;
  2978. {    bool flgs = ((LONG)(src)) < 0;
  2979.     bool flgo = ((LONG)(dst)) < 0;
  2980.     bool flgn = ((LONG)(newv)) < 0;
  2981.     regs.z = ((LONG)(newv)) == 0;
  2982.     regs.v = (flgs != flgo) && (flgn != flgo);
  2983.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  2984.     regs.n = flgn != 0;
  2985.     put_long(dsta,newv);
  2986. }}}}}}
  2987. void op_55c0(UWORD opcode)
  2988. {
  2989.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2990. {{{    int val = cctrue(5) ? 0xff : 0;
  2991.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  2992. }}}}
  2993. void op_55c8(UWORD opcode)
  2994. {
  2995.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  2996. {{    WORD src = regs.d[srcreg];
  2997. {    WORD offs = nextiword();
  2998.     if (!cctrue(5)) {
  2999.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  3000.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  3001.     }
  3002. }}}}
  3003. void op_55d0(UWORD opcode)
  3004. {
  3005.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3006. {{    CPTR srca = regs.a[srcreg];
  3007. {    int val = cctrue(5) ? 0xff : 0;
  3008.     put_byte(srca,val);
  3009. }}}}
  3010. void op_55d8(UWORD opcode)
  3011. {
  3012.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3013. {{    CPTR srca = regs.a[srcreg];
  3014. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  3015. {    int val = cctrue(5) ? 0xff : 0;
  3016.     put_byte(srca,val);
  3017. }}}}}
  3018. void op_55e0(UWORD opcode)
  3019. {
  3020.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3021. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  3022. {    CPTR srca = regs.a[srcreg];
  3023. {    int val = cctrue(5) ? 0xff : 0;
  3024.     put_byte(srca,val);
  3025. }}}}}
  3026. void op_55e8(UWORD opcode)
  3027. {
  3028.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3029. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  3030. {    int val = cctrue(5) ? 0xff : 0;
  3031.     put_byte(srca,val);
  3032. }}}}
  3033. void op_55f0(UWORD opcode)
  3034. {
  3035.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3036. {{    CPTR srca = regs.a[srcreg];
  3037.     UWORD srcdp = nextiword();
  3038.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  3039. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  3040.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  3041.     srca += srcdpr;
  3042. {    int val = cctrue(5) ? 0xff : 0;
  3043.     put_byte(srca,val);
  3044. }}}}}
  3045. void op_55f8(UWORD opcode)
  3046. {
  3047. {{    CPTR srca = (LONG)(WORD)nextiword();
  3048. {    int val = cctrue(5) ? 0xff : 0;
  3049.     put_byte(srca,val);
  3050. }}}}
  3051. void op_55f9(UWORD opcode)
  3052. {
  3053. {{    CPTR srca = nextilong();
  3054. {    int val = cctrue(5) ? 0xff : 0;
  3055.     put_byte(srca,val);
  3056. }}}}
  3057. void op_5600(UWORD opcode)
  3058. {
  3059.     ULONG srcreg = 3;
  3060.     ULONG dstreg = (opcode & 7) >> 0;
  3061. {{    ULONG src = srcreg;
  3062. {    BYTE dst = regs.d[dstreg];
  3063. {    ULONG newv = dst + src;
  3064. {    bool flgs = ((BYTE)(src)) < 0;
  3065.     bool flgo = ((BYTE)(dst)) < 0;
  3066.     bool flgn = ((BYTE)(newv)) < 0;
  3067.     regs.z = ((BYTE)(newv)) == 0;
  3068.     regs.v = (flgs == flgo) && (flgn != flgo);
  3069.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3070.     regs.n = flgn != 0;
  3071.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  3072. }}}}}}
  3073. void op_5610(UWORD opcode)
  3074. {
  3075.     ULONG srcreg = 3;
  3076.     ULONG dstreg = (opcode & 7) >> 0;
  3077. {{    ULONG src = srcreg;
  3078. {    CPTR dsta = regs.a[dstreg];
  3079.     BYTE dst = get_byte(dsta);
  3080. {    ULONG newv = dst + src;
  3081. {    bool flgs = ((BYTE)(src)) < 0;
  3082.     bool flgo = ((BYTE)(dst)) < 0;
  3083.     bool flgn = ((BYTE)(newv)) < 0;
  3084.     regs.z = ((BYTE)(newv)) == 0;
  3085.     regs.v = (flgs == flgo) && (flgn != flgo);
  3086.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3087.     regs.n = flgn != 0;
  3088.     put_byte(dsta,newv);
  3089. }}}}}}
  3090. void op_5618(UWORD opcode)
  3091. {
  3092.     ULONG srcreg = 3;
  3093.     ULONG dstreg = (opcode & 7) >> 0;
  3094. {{    ULONG src = srcreg;
  3095. {    CPTR dsta = regs.a[dstreg];
  3096.     BYTE dst = get_byte(dsta);
  3097. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  3098. {    ULONG newv = dst + src;
  3099. {    bool flgs = ((BYTE)(src)) < 0;
  3100.     bool flgo = ((BYTE)(dst)) < 0;
  3101.     bool flgn = ((BYTE)(newv)) < 0;
  3102.     regs.z = ((BYTE)(newv)) == 0;
  3103.     regs.v = (flgs == flgo) && (flgn != flgo);
  3104.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3105.     regs.n = flgn != 0;
  3106.     put_byte(dsta,newv);
  3107. }}}}}}}
  3108. void op_5620(UWORD opcode)
  3109. {
  3110.     ULONG srcreg = 3;
  3111.     ULONG dstreg = (opcode & 7) >> 0;
  3112. {{    ULONG src = srcreg;
  3113. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  3114. {    CPTR dsta = regs.a[dstreg];
  3115.     BYTE dst = get_byte(dsta);
  3116. {    ULONG newv = dst + src;
  3117. {    bool flgs = ((BYTE)(src)) < 0;
  3118.     bool flgo = ((BYTE)(dst)) < 0;
  3119.     bool flgn = ((BYTE)(newv)) < 0;
  3120.     regs.z = ((BYTE)(newv)) == 0;
  3121.     regs.v = (flgs == flgo) && (flgn != flgo);
  3122.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3123.     regs.n = flgn != 0;
  3124.     put_byte(dsta,newv);
  3125. }}}}}}}
  3126. void op_5628(UWORD opcode)
  3127. {
  3128.     ULONG srcreg = 3;
  3129.     ULONG dstreg = (opcode & 7) >> 0;
  3130. {{    ULONG src = srcreg;
  3131. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3132.     BYTE dst = get_byte(dsta);
  3133. {    ULONG newv = dst + src;
  3134. {    bool flgs = ((BYTE)(src)) < 0;
  3135.     bool flgo = ((BYTE)(dst)) < 0;
  3136.     bool flgn = ((BYTE)(newv)) < 0;
  3137.     regs.z = ((BYTE)(newv)) == 0;
  3138.     regs.v = (flgs == flgo) && (flgn != flgo);
  3139.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3140.     regs.n = flgn != 0;
  3141.     put_byte(dsta,newv);
  3142. }}}}}}
  3143. void op_5630(UWORD opcode)
  3144. {
  3145.     ULONG srcreg = 3;
  3146.     ULONG dstreg = (opcode & 7) >> 0;
  3147. {{    ULONG src = srcreg;
  3148. {    CPTR dsta = regs.a[dstreg];
  3149.     UWORD dstdp = nextiword();
  3150.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3151. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3152.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3153.     dsta += dstdpr;
  3154. {    BYTE dst = get_byte(dsta);
  3155. {    ULONG newv = dst + src;
  3156. {    bool flgs = ((BYTE)(src)) < 0;
  3157.     bool flgo = ((BYTE)(dst)) < 0;
  3158.     bool flgn = ((BYTE)(newv)) < 0;
  3159.     regs.z = ((BYTE)(newv)) == 0;
  3160.     regs.v = (flgs == flgo) && (flgn != flgo);
  3161.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3162.     regs.n = flgn != 0;
  3163.     put_byte(dsta,newv);
  3164. }}}}}}}}
  3165. void op_5638(UWORD opcode)
  3166. {
  3167.     ULONG srcreg = 3;
  3168. {{    ULONG src = srcreg;
  3169. {    CPTR dsta = (LONG)(WORD)nextiword();
  3170.     BYTE dst = get_byte(dsta);
  3171. {    ULONG newv = dst + src;
  3172. {    bool flgs = ((BYTE)(src)) < 0;
  3173.     bool flgo = ((BYTE)(dst)) < 0;
  3174.     bool flgn = ((BYTE)(newv)) < 0;
  3175.     regs.z = ((BYTE)(newv)) == 0;
  3176.     regs.v = (flgs == flgo) && (flgn != flgo);
  3177.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3178.     regs.n = flgn != 0;
  3179.     put_byte(dsta,newv);
  3180. }}}}}}
  3181. void op_5639(UWORD opcode)
  3182. {
  3183.     ULONG srcreg = 3;
  3184. {{    ULONG src = srcreg;
  3185. {    CPTR dsta = nextilong();
  3186.     BYTE dst = get_byte(dsta);
  3187. {    ULONG newv = dst + src;
  3188. {    bool flgs = ((BYTE)(src)) < 0;
  3189.     bool flgo = ((BYTE)(dst)) < 0;
  3190.     bool flgn = ((BYTE)(newv)) < 0;
  3191.     regs.z = ((BYTE)(newv)) == 0;
  3192.     regs.v = (flgs == flgo) && (flgn != flgo);
  3193.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  3194.     regs.n = flgn != 0;
  3195.     put_byte(dsta,newv);
  3196. }}}}}}
  3197. void op_5640(UWORD opcode)
  3198. {
  3199.     ULONG srcreg = 3;
  3200.     ULONG dstreg = (opcode & 7) >> 0;
  3201. {{    ULONG src = srcreg;
  3202. {    WORD dst = regs.d[dstreg];
  3203. {    ULONG newv = dst + src;
  3204. {    bool flgs = ((WORD)(src)) < 0;
  3205.     bool flgo = ((WORD)(dst)) < 0;
  3206.     bool flgn = ((WORD)(newv)) < 0;
  3207.     regs.z = ((WORD)(newv)) == 0;
  3208.     regs.v = (flgs == flgo) && (flgn != flgo);
  3209.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3210.     regs.n = flgn != 0;
  3211.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  3212. }}}}}}
  3213. void op_5648(UWORD opcode)
  3214. {
  3215.     ULONG srcreg = 3;
  3216.     ULONG dstreg = (opcode & 7) >> 0;
  3217. {{    ULONG src = srcreg;
  3218. {    LONG dst = regs.a[dstreg];
  3219. {    ULONG newv = dst + src;
  3220.     regs.a[dstreg] = (newv);
  3221. }}}}}
  3222. void op_5650(UWORD opcode)
  3223. {
  3224.     ULONG srcreg = 3;
  3225.     ULONG dstreg = (opcode & 7) >> 0;
  3226. {{    ULONG src = srcreg;
  3227. {    CPTR dsta = regs.a[dstreg];
  3228.     WORD dst = get_word(dsta);
  3229. {    ULONG newv = dst + src;
  3230. {    bool flgs = ((WORD)(src)) < 0;
  3231.     bool flgo = ((WORD)(dst)) < 0;
  3232.     bool flgn = ((WORD)(newv)) < 0;
  3233.     regs.z = ((WORD)(newv)) == 0;
  3234.     regs.v = (flgs == flgo) && (flgn != flgo);
  3235.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3236.     regs.n = flgn != 0;
  3237.     put_word(dsta,newv);
  3238. }}}}}}
  3239. void op_5658(UWORD opcode)
  3240. {
  3241.     ULONG srcreg = 3;
  3242.     ULONG dstreg = (opcode & 7) >> 0;
  3243. {{    ULONG src = srcreg;
  3244. {    CPTR dsta = regs.a[dstreg];
  3245.     WORD dst = get_word(dsta);
  3246. {    regs.a[dstreg] += 2;
  3247. {    ULONG newv = dst + src;
  3248. {    bool flgs = ((WORD)(src)) < 0;
  3249.     bool flgo = ((WORD)(dst)) < 0;
  3250.     bool flgn = ((WORD)(newv)) < 0;
  3251.     regs.z = ((WORD)(newv)) == 0;
  3252.     regs.v = (flgs == flgo) && (flgn != flgo);
  3253.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3254.     regs.n = flgn != 0;
  3255.     put_word(dsta,newv);
  3256. }}}}}}}
  3257. void op_5660(UWORD opcode)
  3258. {
  3259.     ULONG srcreg = 3;
  3260.     ULONG dstreg = (opcode & 7) >> 0;
  3261. {{    ULONG src = srcreg;
  3262. {    regs.a[dstreg] -= 2;
  3263. {    CPTR dsta = regs.a[dstreg];
  3264.     WORD dst = get_word(dsta);
  3265. {    ULONG newv = dst + src;
  3266. {    bool flgs = ((WORD)(src)) < 0;
  3267.     bool flgo = ((WORD)(dst)) < 0;
  3268.     bool flgn = ((WORD)(newv)) < 0;
  3269.     regs.z = ((WORD)(newv)) == 0;
  3270.     regs.v = (flgs == flgo) && (flgn != flgo);
  3271.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3272.     regs.n = flgn != 0;
  3273.     put_word(dsta,newv);
  3274. }}}}}}}
  3275. void op_5668(UWORD opcode)
  3276. {
  3277.     ULONG srcreg = 3;
  3278.     ULONG dstreg = (opcode & 7) >> 0;
  3279. {{    ULONG src = srcreg;
  3280. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3281.     WORD dst = get_word(dsta);
  3282. {    ULONG newv = dst + src;
  3283. {    bool flgs = ((WORD)(src)) < 0;
  3284.     bool flgo = ((WORD)(dst)) < 0;
  3285.     bool flgn = ((WORD)(newv)) < 0;
  3286.     regs.z = ((WORD)(newv)) == 0;
  3287.     regs.v = (flgs == flgo) && (flgn != flgo);
  3288.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3289.     regs.n = flgn != 0;
  3290.     put_word(dsta,newv);
  3291. }}}}}}
  3292. void op_5670(UWORD opcode)
  3293. {
  3294.     ULONG srcreg = 3;
  3295.     ULONG dstreg = (opcode & 7) >> 0;
  3296. {{    ULONG src = srcreg;
  3297. {    CPTR dsta = regs.a[dstreg];
  3298.     UWORD dstdp = nextiword();
  3299.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3300. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3301.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3302.     dsta += dstdpr;
  3303. {    WORD dst = get_word(dsta);
  3304. {    ULONG newv = dst + src;
  3305. {    bool flgs = ((WORD)(src)) < 0;
  3306.     bool flgo = ((WORD)(dst)) < 0;
  3307.     bool flgn = ((WORD)(newv)) < 0;
  3308.     regs.z = ((WORD)(newv)) == 0;
  3309.     regs.v = (flgs == flgo) && (flgn != flgo);
  3310.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3311.     regs.n = flgn != 0;
  3312.     put_word(dsta,newv);
  3313. }}}}}}}}
  3314. void op_5678(UWORD opcode)
  3315. {
  3316.     ULONG srcreg = 3;
  3317. {{    ULONG src = srcreg;
  3318. {    CPTR dsta = (LONG)(WORD)nextiword();
  3319.     WORD dst = get_word(dsta);
  3320. {    ULONG newv = dst + src;
  3321. {    bool flgs = ((WORD)(src)) < 0;
  3322.     bool flgo = ((WORD)(dst)) < 0;
  3323.     bool flgn = ((WORD)(newv)) < 0;
  3324.     regs.z = ((WORD)(newv)) == 0;
  3325.     regs.v = (flgs == flgo) && (flgn != flgo);
  3326.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3327.     regs.n = flgn != 0;
  3328.     put_word(dsta,newv);
  3329. }}}}}}
  3330. void op_5679(UWORD opcode)
  3331. {
  3332.     ULONG srcreg = 3;
  3333. {{    ULONG src = srcreg;
  3334. {    CPTR dsta = nextilong();
  3335.     WORD dst = get_word(dsta);
  3336. {    ULONG newv = dst + src;
  3337. {    bool flgs = ((WORD)(src)) < 0;
  3338.     bool flgo = ((WORD)(dst)) < 0;
  3339.     bool flgn = ((WORD)(newv)) < 0;
  3340.     regs.z = ((WORD)(newv)) == 0;
  3341.     regs.v = (flgs == flgo) && (flgn != flgo);
  3342.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  3343.     regs.n = flgn != 0;
  3344.     put_word(dsta,newv);
  3345. }}}}}}
  3346. void op_5680(UWORD opcode)
  3347. {
  3348.     ULONG srcreg = 3;
  3349.     ULONG dstreg = (opcode & 7) >> 0;
  3350. {{    ULONG src = srcreg;
  3351. {    LONG dst = regs.d[dstreg];
  3352. {    ULONG newv = dst + src;
  3353. {    bool flgs = ((LONG)(src)) < 0;
  3354.     bool flgo = ((LONG)(dst)) < 0;
  3355.     bool flgn = ((LONG)(newv)) < 0;
  3356.     regs.z = ((LONG)(newv)) == 0;
  3357.     regs.v = (flgs == flgo) && (flgn != flgo);
  3358.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3359.     regs.n = flgn != 0;
  3360.     regs.d[dstreg] = (newv);
  3361. }}}}}}
  3362. void op_5688(UWORD opcode)
  3363. {
  3364.     ULONG srcreg = 3;
  3365.     ULONG dstreg = (opcode & 7) >> 0;
  3366. {{    ULONG src = srcreg;
  3367. {    LONG dst = regs.a[dstreg];
  3368. {    ULONG newv = dst + src;
  3369.     regs.a[dstreg] = (newv);
  3370. }}}}}
  3371. void op_5690(UWORD opcode)
  3372. {
  3373.     ULONG srcreg = 3;
  3374.     ULONG dstreg = (opcode & 7) >> 0;
  3375. {{    ULONG src = srcreg;
  3376. {    CPTR dsta = regs.a[dstreg];
  3377.     LONG dst = get_long(dsta);
  3378. {    ULONG newv = dst + src;
  3379. {    bool flgs = ((LONG)(src)) < 0;
  3380.     bool flgo = ((LONG)(dst)) < 0;
  3381.     bool flgn = ((LONG)(newv)) < 0;
  3382.     regs.z = ((LONG)(newv)) == 0;
  3383.     regs.v = (flgs == flgo) && (flgn != flgo);
  3384.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3385.     regs.n = flgn != 0;
  3386.     put_long(dsta,newv);
  3387. }}}}}}
  3388. void op_5698(UWORD opcode)
  3389. {
  3390.     ULONG srcreg = 3;
  3391.     ULONG dstreg = (opcode & 7) >> 0;
  3392. {{    ULONG src = srcreg;
  3393. {    CPTR dsta = regs.a[dstreg];
  3394.     LONG dst = get_long(dsta);
  3395. {    regs.a[dstreg] += 4;
  3396. {    ULONG newv = dst + src;
  3397. {    bool flgs = ((LONG)(src)) < 0;
  3398.     bool flgo = ((LONG)(dst)) < 0;
  3399.     bool flgn = ((LONG)(newv)) < 0;
  3400.     regs.z = ((LONG)(newv)) == 0;
  3401.     regs.v = (flgs == flgo) && (flgn != flgo);
  3402.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3403.     regs.n = flgn != 0;
  3404.     put_long(dsta,newv);
  3405. }}}}}}}
  3406. void op_56a0(UWORD opcode)
  3407. {
  3408.     ULONG srcreg = 3;
  3409.     ULONG dstreg = (opcode & 7) >> 0;
  3410. {{    ULONG src = srcreg;
  3411. {    regs.a[dstreg] -= 4;
  3412. {    CPTR dsta = regs.a[dstreg];
  3413.     LONG dst = get_long(dsta);
  3414. {    ULONG newv = dst + src;
  3415. {    bool flgs = ((LONG)(src)) < 0;
  3416.     bool flgo = ((LONG)(dst)) < 0;
  3417.     bool flgn = ((LONG)(newv)) < 0;
  3418.     regs.z = ((LONG)(newv)) == 0;
  3419.     regs.v = (flgs == flgo) && (flgn != flgo);
  3420.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3421.     regs.n = flgn != 0;
  3422.     put_long(dsta,newv);
  3423. }}}}}}}
  3424. void op_56a8(UWORD opcode)
  3425. {
  3426.     ULONG srcreg = 3;
  3427.     ULONG dstreg = (opcode & 7) >> 0;
  3428. {{    ULONG src = srcreg;
  3429. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3430.     LONG dst = get_long(dsta);
  3431. {    ULONG newv = dst + src;
  3432. {    bool flgs = ((LONG)(src)) < 0;
  3433.     bool flgo = ((LONG)(dst)) < 0;
  3434.     bool flgn = ((LONG)(newv)) < 0;
  3435.     regs.z = ((LONG)(newv)) == 0;
  3436.     regs.v = (flgs == flgo) && (flgn != flgo);
  3437.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3438.     regs.n = flgn != 0;
  3439.     put_long(dsta,newv);
  3440. }}}}}}
  3441. void op_56b0(UWORD opcode)
  3442. {
  3443.     ULONG srcreg = 3;
  3444.     ULONG dstreg = (opcode & 7) >> 0;
  3445. {{    ULONG src = srcreg;
  3446. {    CPTR dsta = regs.a[dstreg];
  3447.     UWORD dstdp = nextiword();
  3448.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3449. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3450.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3451.     dsta += dstdpr;
  3452. {    LONG dst = get_long(dsta);
  3453. {    ULONG newv = dst + src;
  3454. {    bool flgs = ((LONG)(src)) < 0;
  3455.     bool flgo = ((LONG)(dst)) < 0;
  3456.     bool flgn = ((LONG)(newv)) < 0;
  3457.     regs.z = ((LONG)(newv)) == 0;
  3458.     regs.v = (flgs == flgo) && (flgn != flgo);
  3459.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3460.     regs.n = flgn != 0;
  3461.     put_long(dsta,newv);
  3462. }}}}}}}}
  3463. void op_56b8(UWORD opcode)
  3464. {
  3465.     ULONG srcreg = 3;
  3466. {{    ULONG src = srcreg;
  3467. {    CPTR dsta = (LONG)(WORD)nextiword();
  3468.     LONG dst = get_long(dsta);
  3469. {    ULONG newv = dst + src;
  3470. {    bool flgs = ((LONG)(src)) < 0;
  3471.     bool flgo = ((LONG)(dst)) < 0;
  3472.     bool flgn = ((LONG)(newv)) < 0;
  3473.     regs.z = ((LONG)(newv)) == 0;
  3474.     regs.v = (flgs == flgo) && (flgn != flgo);
  3475.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3476.     regs.n = flgn != 0;
  3477.     put_long(dsta,newv);
  3478. }}}}}}
  3479. void op_56b9(UWORD opcode)
  3480. {
  3481.     ULONG srcreg = 3;
  3482. {{    ULONG src = srcreg;
  3483. {    CPTR dsta = nextilong();
  3484.     LONG dst = get_long(dsta);
  3485. {    ULONG newv = dst + src;
  3486. {    bool flgs = ((LONG)(src)) < 0;
  3487.     bool flgo = ((LONG)(dst)) < 0;
  3488.     bool flgn = ((LONG)(newv)) < 0;
  3489.     regs.z = ((LONG)(newv)) == 0;
  3490.     regs.v = (flgs == flgo) && (flgn != flgo);
  3491.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  3492.     regs.n = flgn != 0;
  3493.     put_long(dsta,newv);
  3494. }}}}}}
  3495. void op_56c0(UWORD opcode)
  3496. {
  3497.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3498. {{{    int val = cctrue(6) ? 0xff : 0;
  3499.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  3500. }}}}
  3501. void op_56c8(UWORD opcode)
  3502. {
  3503.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3504. {{    WORD src = regs.d[srcreg];
  3505. {    WORD offs = nextiword();
  3506.     if (!cctrue(6)) {
  3507.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  3508.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  3509.     }
  3510. }}}}
  3511. void op_56d0(UWORD opcode)
  3512. {
  3513.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3514. {{    CPTR srca = regs.a[srcreg];
  3515. {    int val = cctrue(6) ? 0xff : 0;
  3516.     put_byte(srca,val);
  3517. }}}}
  3518. void op_56d8(UWORD opcode)
  3519. {
  3520.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3521. {{    CPTR srca = regs.a[srcreg];
  3522. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  3523. {    int val = cctrue(6) ? 0xff : 0;
  3524.     put_byte(srca,val);
  3525. }}}}}
  3526. void op_56e0(UWORD opcode)
  3527. {
  3528.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3529. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  3530. {    CPTR srca = regs.a[srcreg];
  3531. {    int val = cctrue(6) ? 0xff : 0;
  3532.     put_byte(srca,val);
  3533. }}}}}
  3534. void op_56e8(UWORD opcode)
  3535. {
  3536.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3537. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  3538. {    int val = cctrue(6) ? 0xff : 0;
  3539.     put_byte(srca,val);
  3540. }}}}
  3541. void op_56f0(UWORD opcode)
  3542. {
  3543.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  3544. {{    CPTR srca = regs.a[srcreg];
  3545.     UWORD srcdp = nextiword();
  3546.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  3547. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  3548.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  3549.     srca += srcdpr;
  3550. {    int val = cctrue(6) ? 0xff : 0;
  3551.     put_byte(srca,val);
  3552. }}}}}
  3553. void op_56f8(UWORD opcode)
  3554. {
  3555. {{    CPTR srca = (LONG)(WORD)nextiword();
  3556. {    int val = cctrue(6) ? 0xff : 0;
  3557.     put_byte(srca,val);
  3558. }}}}
  3559. void op_56f9(UWORD opcode)
  3560. {
  3561. {{    CPTR srca = nextilong();
  3562. {    int val = cctrue(6) ? 0xff : 0;
  3563.     put_byte(srca,val);
  3564. }}}}
  3565. void op_5700(UWORD opcode)
  3566. {
  3567.     ULONG srcreg = 3;
  3568.     ULONG dstreg = (opcode & 7) >> 0;
  3569. {{    ULONG src = srcreg;
  3570. {    BYTE dst = regs.d[dstreg];
  3571. {    ULONG newv = dst - src;
  3572. {    bool flgs = ((BYTE)(src)) < 0;
  3573.     bool flgo = ((BYTE)(dst)) < 0;
  3574.     bool flgn = ((BYTE)(newv)) < 0;
  3575.     regs.z = ((BYTE)(newv)) == 0;
  3576.     regs.v = (flgs != flgo) && (flgn != flgo);
  3577.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3578.     regs.n = flgn != 0;
  3579.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  3580. }}}}}}
  3581. void op_5710(UWORD opcode)
  3582. {
  3583.     ULONG srcreg = 3;
  3584.     ULONG dstreg = (opcode & 7) >> 0;
  3585. {{    ULONG src = srcreg;
  3586. {    CPTR dsta = regs.a[dstreg];
  3587.     BYTE dst = get_byte(dsta);
  3588. {    ULONG newv = dst - src;
  3589. {    bool flgs = ((BYTE)(src)) < 0;
  3590.     bool flgo = ((BYTE)(dst)) < 0;
  3591.     bool flgn = ((BYTE)(newv)) < 0;
  3592.     regs.z = ((BYTE)(newv)) == 0;
  3593.     regs.v = (flgs != flgo) && (flgn != flgo);
  3594.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3595.     regs.n = flgn != 0;
  3596.     put_byte(dsta,newv);
  3597. }}}}}}
  3598. void op_5718(UWORD opcode)
  3599. {
  3600.     ULONG srcreg = 3;
  3601.     ULONG dstreg = (opcode & 7) >> 0;
  3602. {{    ULONG src = srcreg;
  3603. {    CPTR dsta = regs.a[dstreg];
  3604.     BYTE dst = get_byte(dsta);
  3605. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  3606. {    ULONG newv = dst - src;
  3607. {    bool flgs = ((BYTE)(src)) < 0;
  3608.     bool flgo = ((BYTE)(dst)) < 0;
  3609.     bool flgn = ((BYTE)(newv)) < 0;
  3610.     regs.z = ((BYTE)(newv)) == 0;
  3611.     regs.v = (flgs != flgo) && (flgn != flgo);
  3612.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3613.     regs.n = flgn != 0;
  3614.     put_byte(dsta,newv);
  3615. }}}}}}}
  3616. void op_5720(UWORD opcode)
  3617. {
  3618.     ULONG srcreg = 3;
  3619.     ULONG dstreg = (opcode & 7) >> 0;
  3620. {{    ULONG src = srcreg;
  3621. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  3622. {    CPTR dsta = regs.a[dstreg];
  3623.     BYTE dst = get_byte(dsta);
  3624. {    ULONG newv = dst - src;
  3625. {    bool flgs = ((BYTE)(src)) < 0;
  3626.     bool flgo = ((BYTE)(dst)) < 0;
  3627.     bool flgn = ((BYTE)(newv)) < 0;
  3628.     regs.z = ((BYTE)(newv)) == 0;
  3629.     regs.v = (flgs != flgo) && (flgn != flgo);
  3630.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3631.     regs.n = flgn != 0;
  3632.     put_byte(dsta,newv);
  3633. }}}}}}}
  3634. void op_5728(UWORD opcode)
  3635. {
  3636.     ULONG srcreg = 3;
  3637.     ULONG dstreg = (opcode & 7) >> 0;
  3638. {{    ULONG src = srcreg;
  3639. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3640.     BYTE dst = get_byte(dsta);
  3641. {    ULONG newv = dst - src;
  3642. {    bool flgs = ((BYTE)(src)) < 0;
  3643.     bool flgo = ((BYTE)(dst)) < 0;
  3644.     bool flgn = ((BYTE)(newv)) < 0;
  3645.     regs.z = ((BYTE)(newv)) == 0;
  3646.     regs.v = (flgs != flgo) && (flgn != flgo);
  3647.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3648.     regs.n = flgn != 0;
  3649.     put_byte(dsta,newv);
  3650. }}}}}}
  3651. void op_5730(UWORD opcode)
  3652. {
  3653.     ULONG srcreg = 3;
  3654.     ULONG dstreg = (opcode & 7) >> 0;
  3655. {{    ULONG src = srcreg;
  3656. {    CPTR dsta = regs.a[dstreg];
  3657.     UWORD dstdp = nextiword();
  3658.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3659. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3660.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3661.     dsta += dstdpr;
  3662. {    BYTE dst = get_byte(dsta);
  3663. {    ULONG newv = dst - src;
  3664. {    bool flgs = ((BYTE)(src)) < 0;
  3665.     bool flgo = ((BYTE)(dst)) < 0;
  3666.     bool flgn = ((BYTE)(newv)) < 0;
  3667.     regs.z = ((BYTE)(newv)) == 0;
  3668.     regs.v = (flgs != flgo) && (flgn != flgo);
  3669.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3670.     regs.n = flgn != 0;
  3671.     put_byte(dsta,newv);
  3672. }}}}}}}}
  3673. void op_5738(UWORD opcode)
  3674. {
  3675.     ULONG srcreg = 3;
  3676. {{    ULONG src = srcreg;
  3677. {    CPTR dsta = (LONG)(WORD)nextiword();
  3678.     BYTE dst = get_byte(dsta);
  3679. {    ULONG newv = dst - src;
  3680. {    bool flgs = ((BYTE)(src)) < 0;
  3681.     bool flgo = ((BYTE)(dst)) < 0;
  3682.     bool flgn = ((BYTE)(newv)) < 0;
  3683.     regs.z = ((BYTE)(newv)) == 0;
  3684.     regs.v = (flgs != flgo) && (flgn != flgo);
  3685.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3686.     regs.n = flgn != 0;
  3687.     put_byte(dsta,newv);
  3688. }}}}}}
  3689. void op_5739(UWORD opcode)
  3690. {
  3691.     ULONG srcreg = 3;
  3692. {{    ULONG src = srcreg;
  3693. {    CPTR dsta = nextilong();
  3694.     BYTE dst = get_byte(dsta);
  3695. {    ULONG newv = dst - src;
  3696. {    bool flgs = ((BYTE)(src)) < 0;
  3697.     bool flgo = ((BYTE)(dst)) < 0;
  3698.     bool flgn = ((BYTE)(newv)) < 0;
  3699.     regs.z = ((BYTE)(newv)) == 0;
  3700.     regs.v = (flgs != flgo) && (flgn != flgo);
  3701.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  3702.     regs.n = flgn != 0;
  3703.     put_byte(dsta,newv);
  3704. }}}}}}
  3705. void op_5740(UWORD opcode)
  3706. {
  3707.     ULONG srcreg = 3;
  3708.     ULONG dstreg = (opcode & 7) >> 0;
  3709. {{    ULONG src = srcreg;
  3710. {    WORD dst = regs.d[dstreg];
  3711. {    ULONG newv = dst - src;
  3712. {    bool flgs = ((WORD)(src)) < 0;
  3713.     bool flgo = ((WORD)(dst)) < 0;
  3714.     bool flgn = ((WORD)(newv)) < 0;
  3715.     regs.z = ((WORD)(newv)) == 0;
  3716.     regs.v = (flgs != flgo) && (flgn != flgo);
  3717.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3718.     regs.n = flgn != 0;
  3719.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  3720. }}}}}}
  3721. void op_5748(UWORD opcode)
  3722. {
  3723.     ULONG srcreg = 3;
  3724.     ULONG dstreg = (opcode & 7) >> 0;
  3725. {{    ULONG src = srcreg;
  3726. {    LONG dst = regs.a[dstreg];
  3727. {    ULONG newv = dst - src;
  3728.     regs.a[dstreg] = (newv);
  3729. }}}}}
  3730. void op_5750(UWORD opcode)
  3731. {
  3732.     ULONG srcreg = 3;
  3733.     ULONG dstreg = (opcode & 7) >> 0;
  3734. {{    ULONG src = srcreg;
  3735. {    CPTR dsta = regs.a[dstreg];
  3736.     WORD dst = get_word(dsta);
  3737. {    ULONG newv = dst - src;
  3738. {    bool flgs = ((WORD)(src)) < 0;
  3739.     bool flgo = ((WORD)(dst)) < 0;
  3740.     bool flgn = ((WORD)(newv)) < 0;
  3741.     regs.z = ((WORD)(newv)) == 0;
  3742.     regs.v = (flgs != flgo) && (flgn != flgo);
  3743.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3744.     regs.n = flgn != 0;
  3745.     put_word(dsta,newv);
  3746. }}}}}}
  3747. void op_5758(UWORD opcode)
  3748. {
  3749.     ULONG srcreg = 3;
  3750.     ULONG dstreg = (opcode & 7) >> 0;
  3751. {{    ULONG src = srcreg;
  3752. {    CPTR dsta = regs.a[dstreg];
  3753.     WORD dst = get_word(dsta);
  3754. {    regs.a[dstreg] += 2;
  3755. {    ULONG newv = dst - src;
  3756. {    bool flgs = ((WORD)(src)) < 0;
  3757.     bool flgo = ((WORD)(dst)) < 0;
  3758.     bool flgn = ((WORD)(newv)) < 0;
  3759.     regs.z = ((WORD)(newv)) == 0;
  3760.     regs.v = (flgs != flgo) && (flgn != flgo);
  3761.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3762.     regs.n = flgn != 0;
  3763.     put_word(dsta,newv);
  3764. }}}}}}}
  3765. void op_5760(UWORD opcode)
  3766. {
  3767.     ULONG srcreg = 3;
  3768.     ULONG dstreg = (opcode & 7) >> 0;
  3769. {{    ULONG src = srcreg;
  3770. {    regs.a[dstreg] -= 2;
  3771. {    CPTR dsta = regs.a[dstreg];
  3772.     WORD dst = get_word(dsta);
  3773. {    ULONG newv = dst - src;
  3774. {    bool flgs = ((WORD)(src)) < 0;
  3775.     bool flgo = ((WORD)(dst)) < 0;
  3776.     bool flgn = ((WORD)(newv)) < 0;
  3777.     regs.z = ((WORD)(newv)) == 0;
  3778.     regs.v = (flgs != flgo) && (flgn != flgo);
  3779.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3780.     regs.n = flgn != 0;
  3781.     put_word(dsta,newv);
  3782. }}}}}}}
  3783. void op_5768(UWORD opcode)
  3784. {
  3785.     ULONG srcreg = 3;
  3786.     ULONG dstreg = (opcode & 7) >> 0;
  3787. {{    ULONG src = srcreg;
  3788. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3789.     WORD dst = get_word(dsta);
  3790. {    ULONG newv = dst - src;
  3791. {    bool flgs = ((WORD)(src)) < 0;
  3792.     bool flgo = ((WORD)(dst)) < 0;
  3793.     bool flgn = ((WORD)(newv)) < 0;
  3794.     regs.z = ((WORD)(newv)) == 0;
  3795.     regs.v = (flgs != flgo) && (flgn != flgo);
  3796.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3797.     regs.n = flgn != 0;
  3798.     put_word(dsta,newv);
  3799. }}}}}}
  3800. void op_5770(UWORD opcode)
  3801. {
  3802.     ULONG srcreg = 3;
  3803.     ULONG dstreg = (opcode & 7) >> 0;
  3804. {{    ULONG src = srcreg;
  3805. {    CPTR dsta = regs.a[dstreg];
  3806.     UWORD dstdp = nextiword();
  3807.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3808. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3809.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3810.     dsta += dstdpr;
  3811. {    WORD dst = get_word(dsta);
  3812. {    ULONG newv = dst - src;
  3813. {    bool flgs = ((WORD)(src)) < 0;
  3814.     bool flgo = ((WORD)(dst)) < 0;
  3815.     bool flgn = ((WORD)(newv)) < 0;
  3816.     regs.z = ((WORD)(newv)) == 0;
  3817.     regs.v = (flgs != flgo) && (flgn != flgo);
  3818.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3819.     regs.n = flgn != 0;
  3820.     put_word(dsta,newv);
  3821. }}}}}}}}
  3822. void op_5778(UWORD opcode)
  3823. {
  3824.     ULONG srcreg = 3;
  3825. {{    ULONG src = srcreg;
  3826. {    CPTR dsta = (LONG)(WORD)nextiword();
  3827.     WORD dst = get_word(dsta);
  3828. {    ULONG newv = dst - src;
  3829. {    bool flgs = ((WORD)(src)) < 0;
  3830.     bool flgo = ((WORD)(dst)) < 0;
  3831.     bool flgn = ((WORD)(newv)) < 0;
  3832.     regs.z = ((WORD)(newv)) == 0;
  3833.     regs.v = (flgs != flgo) && (flgn != flgo);
  3834.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3835.     regs.n = flgn != 0;
  3836.     put_word(dsta,newv);
  3837. }}}}}}
  3838. void op_5779(UWORD opcode)
  3839. {
  3840.     ULONG srcreg = 3;
  3841. {{    ULONG src = srcreg;
  3842. {    CPTR dsta = nextilong();
  3843.     WORD dst = get_word(dsta);
  3844. {    ULONG newv = dst - src;
  3845. {    bool flgs = ((WORD)(src)) < 0;
  3846.     bool flgo = ((WORD)(dst)) < 0;
  3847.     bool flgn = ((WORD)(newv)) < 0;
  3848.     regs.z = ((WORD)(newv)) == 0;
  3849.     regs.v = (flgs != flgo) && (flgn != flgo);
  3850.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  3851.     regs.n = flgn != 0;
  3852.     put_word(dsta,newv);
  3853. }}}}}}
  3854. void op_5780(UWORD opcode)
  3855. {
  3856.     ULONG srcreg = 3;
  3857.     ULONG dstreg = (opcode & 7) >> 0;
  3858. {{    ULONG src = srcreg;
  3859. {    LONG dst = regs.d[dstreg];
  3860. {    ULONG newv = dst - src;
  3861. {    bool flgs = ((LONG)(src)) < 0;
  3862.     bool flgo = ((LONG)(dst)) < 0;
  3863.     bool flgn = ((LONG)(newv)) < 0;
  3864.     regs.z = ((LONG)(newv)) == 0;
  3865.     regs.v = (flgs != flgo) && (flgn != flgo);
  3866.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3867.     regs.n = flgn != 0;
  3868.     regs.d[dstreg] = (newv);
  3869. }}}}}}
  3870. void op_5788(UWORD opcode)
  3871. {
  3872.     ULONG srcreg = 3;
  3873.     ULONG dstreg = (opcode & 7) >> 0;
  3874. {{    ULONG src = srcreg;
  3875. {    LONG dst = regs.a[dstreg];
  3876. {    ULONG newv = dst - src;
  3877.     regs.a[dstreg] = (newv);
  3878. }}}}}
  3879. void op_5790(UWORD opcode)
  3880. {
  3881.     ULONG srcreg = 3;
  3882.     ULONG dstreg = (opcode & 7) >> 0;
  3883. {{    ULONG src = srcreg;
  3884. {    CPTR dsta = regs.a[dstreg];
  3885.     LONG dst = get_long(dsta);
  3886. {    ULONG newv = dst - src;
  3887. {    bool flgs = ((LONG)(src)) < 0;
  3888.     bool flgo = ((LONG)(dst)) < 0;
  3889.     bool flgn = ((LONG)(newv)) < 0;
  3890.     regs.z = ((LONG)(newv)) == 0;
  3891.     regs.v = (flgs != flgo) && (flgn != flgo);
  3892.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3893.     regs.n = flgn != 0;
  3894.     put_long(dsta,newv);
  3895. }}}}}}
  3896. void op_5798(UWORD opcode)
  3897. {
  3898.     ULONG srcreg = 3;
  3899.     ULONG dstreg = (opcode & 7) >> 0;
  3900. {{    ULONG src = srcreg;
  3901. {    CPTR dsta = regs.a[dstreg];
  3902.     LONG dst = get_long(dsta);
  3903. {    regs.a[dstreg] += 4;
  3904. {    ULONG newv = dst - src;
  3905. {    bool flgs = ((LONG)(src)) < 0;
  3906.     bool flgo = ((LONG)(dst)) < 0;
  3907.     bool flgn = ((LONG)(newv)) < 0;
  3908.     regs.z = ((LONG)(newv)) == 0;
  3909.     regs.v = (flgs != flgo) && (flgn != flgo);
  3910.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3911.     regs.n = flgn != 0;
  3912.     put_long(dsta,newv);
  3913. }}}}}}}
  3914. void op_57a0(UWORD opcode)
  3915. {
  3916.     ULONG srcreg = 3;
  3917.     ULONG dstreg = (opcode & 7) >> 0;
  3918. {{    ULONG src = srcreg;
  3919. {    regs.a[dstreg] -= 4;
  3920. {    CPTR dsta = regs.a[dstreg];
  3921.     LONG dst = get_long(dsta);
  3922. {    ULONG newv = dst - src;
  3923. {    bool flgs = ((LONG)(src)) < 0;
  3924.     bool flgo = ((LONG)(dst)) < 0;
  3925.     bool flgn = ((LONG)(newv)) < 0;
  3926.     regs.z = ((LONG)(newv)) == 0;
  3927.     regs.v = (flgs != flgo) && (flgn != flgo);
  3928.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3929.     regs.n = flgn != 0;
  3930.     put_long(dsta,newv);
  3931. }}}}}}}
  3932. void op_57a8(UWORD opcode)
  3933. {
  3934.     ULONG srcreg = 3;
  3935.     ULONG dstreg = (opcode & 7) >> 0;
  3936. {{    ULONG src = srcreg;
  3937. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  3938.     LONG dst = get_long(dsta);
  3939. {    ULONG newv = dst - src;
  3940. {    bool flgs = ((LONG)(src)) < 0;
  3941.     bool flgo = ((LONG)(dst)) < 0;
  3942.     bool flgn = ((LONG)(newv)) < 0;
  3943.     regs.z = ((LONG)(newv)) == 0;
  3944.     regs.v = (flgs != flgo) && (flgn != flgo);
  3945.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3946.     regs.n = flgn != 0;
  3947.     put_long(dsta,newv);
  3948. }}}}}}
  3949. void op_57b0(UWORD opcode)
  3950. {
  3951.     ULONG srcreg = 3;
  3952.     ULONG dstreg = (opcode & 7) >> 0;
  3953. {{    ULONG src = srcreg;
  3954. {    CPTR dsta = regs.a[dstreg];
  3955.     UWORD dstdp = nextiword();
  3956.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  3957. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  3958.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  3959.     dsta += dstdpr;
  3960. {    LONG dst = get_long(dsta);
  3961. {    ULONG newv = dst - src;
  3962. {    bool flgs = ((LONG)(src)) < 0;
  3963.     bool flgo = ((LONG)(dst)) < 0;
  3964.     bool flgn = ((LONG)(newv)) < 0;
  3965.     regs.z = ((LONG)(newv)) == 0;
  3966.     regs.v = (flgs != flgo) && (flgn != flgo);
  3967.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3968.     regs.n = flgn != 0;
  3969.     put_long(dsta,newv);
  3970. }}}}}}}}
  3971. void op_57b8(UWORD opcode)
  3972. {
  3973.     ULONG srcreg = 3;
  3974. {{    ULONG src = srcreg;
  3975. {    CPTR dsta = (LONG)(WORD)nextiword();
  3976.     LONG dst = get_long(dsta);
  3977. {    ULONG newv = dst - src;
  3978. {    bool flgs = ((LONG)(src)) < 0;
  3979.     bool flgo = ((LONG)(dst)) < 0;
  3980.     bool flgn = ((LONG)(newv)) < 0;
  3981.     regs.z = ((LONG)(newv)) == 0;
  3982.     regs.v = (flgs != flgo) && (flgn != flgo);
  3983.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  3984.     regs.n = flgn != 0;
  3985.     put_long(dsta,newv);
  3986. }}}}}}
  3987. void op_57b9(UWORD opcode)
  3988. {
  3989.     ULONG srcreg = 3;
  3990. {{    ULONG src = srcreg;
  3991. {    CPTR dsta = nextilong();
  3992.     LONG dst = get_long(dsta);
  3993. {    ULONG newv = dst - src;
  3994. {    bool flgs = ((LONG)(src)) < 0;
  3995.     bool flgo = ((LONG)(dst)) < 0;
  3996.     bool flgn = ((LONG)(newv)) < 0;
  3997.     regs.z = ((LONG)(newv)) == 0;
  3998.     regs.v = (flgs != flgo) && (flgn != flgo);
  3999.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4000.     regs.n = flgn != 0;
  4001.     put_long(dsta,newv);
  4002. }}}}}}
  4003. void op_57c0(UWORD opcode)
  4004. {
  4005.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4006. {{{    int val = cctrue(7) ? 0xff : 0;
  4007.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  4008. }}}}
  4009. void op_57c8(UWORD opcode)
  4010. {
  4011.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4012. {{    WORD src = regs.d[srcreg];
  4013. {    WORD offs = nextiword();
  4014.     if (!cctrue(7)) {
  4015.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  4016.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  4017.     }
  4018. }}}}
  4019. void op_57d0(UWORD opcode)
  4020. {
  4021.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4022. {{    CPTR srca = regs.a[srcreg];
  4023. {    int val = cctrue(7) ? 0xff : 0;
  4024.     put_byte(srca,val);
  4025. }}}}
  4026. void op_57d8(UWORD opcode)
  4027. {
  4028.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4029. {{    CPTR srca = regs.a[srcreg];
  4030. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  4031. {    int val = cctrue(7) ? 0xff : 0;
  4032.     put_byte(srca,val);
  4033. }}}}}
  4034. void op_57e0(UWORD opcode)
  4035. {
  4036.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4037. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  4038. {    CPTR srca = regs.a[srcreg];
  4039. {    int val = cctrue(7) ? 0xff : 0;
  4040.     put_byte(srca,val);
  4041. }}}}}
  4042. void op_57e8(UWORD opcode)
  4043. {
  4044.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4045. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  4046. {    int val = cctrue(7) ? 0xff : 0;
  4047.     put_byte(srca,val);
  4048. }}}}
  4049. void op_57f0(UWORD opcode)
  4050. {
  4051.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4052. {{    CPTR srca = regs.a[srcreg];
  4053.     UWORD srcdp = nextiword();
  4054.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  4055. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  4056.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  4057.     srca += srcdpr;
  4058. {    int val = cctrue(7) ? 0xff : 0;
  4059.     put_byte(srca,val);
  4060. }}}}}
  4061. void op_57f8(UWORD opcode)
  4062. {
  4063. {{    CPTR srca = (LONG)(WORD)nextiword();
  4064. {    int val = cctrue(7) ? 0xff : 0;
  4065.     put_byte(srca,val);
  4066. }}}}
  4067. void op_57f9(UWORD opcode)
  4068. {
  4069. {{    CPTR srca = nextilong();
  4070. {    int val = cctrue(7) ? 0xff : 0;
  4071.     put_byte(srca,val);
  4072. }}}}
  4073. void op_5800(UWORD opcode)
  4074. {
  4075.     ULONG srcreg = 4;
  4076.     ULONG dstreg = (opcode & 7) >> 0;
  4077. {{    ULONG src = srcreg;
  4078. {    BYTE dst = regs.d[dstreg];
  4079. {    ULONG newv = dst + src;
  4080. {    bool flgs = ((BYTE)(src)) < 0;
  4081.     bool flgo = ((BYTE)(dst)) < 0;
  4082.     bool flgn = ((BYTE)(newv)) < 0;
  4083.     regs.z = ((BYTE)(newv)) == 0;
  4084.     regs.v = (flgs == flgo) && (flgn != flgo);
  4085.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4086.     regs.n = flgn != 0;
  4087.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  4088. }}}}}}
  4089. void op_5810(UWORD opcode)
  4090. {
  4091.     ULONG srcreg = 4;
  4092.     ULONG dstreg = (opcode & 7) >> 0;
  4093. {{    ULONG src = srcreg;
  4094. {    CPTR dsta = regs.a[dstreg];
  4095.     BYTE dst = get_byte(dsta);
  4096. {    ULONG newv = dst + src;
  4097. {    bool flgs = ((BYTE)(src)) < 0;
  4098.     bool flgo = ((BYTE)(dst)) < 0;
  4099.     bool flgn = ((BYTE)(newv)) < 0;
  4100.     regs.z = ((BYTE)(newv)) == 0;
  4101.     regs.v = (flgs == flgo) && (flgn != flgo);
  4102.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4103.     regs.n = flgn != 0;
  4104.     put_byte(dsta,newv);
  4105. }}}}}}
  4106. void op_5818(UWORD opcode)
  4107. {
  4108.     ULONG srcreg = 4;
  4109.     ULONG dstreg = (opcode & 7) >> 0;
  4110. {{    ULONG src = srcreg;
  4111. {    CPTR dsta = regs.a[dstreg];
  4112.     BYTE dst = get_byte(dsta);
  4113. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  4114. {    ULONG newv = dst + src;
  4115. {    bool flgs = ((BYTE)(src)) < 0;
  4116.     bool flgo = ((BYTE)(dst)) < 0;
  4117.     bool flgn = ((BYTE)(newv)) < 0;
  4118.     regs.z = ((BYTE)(newv)) == 0;
  4119.     regs.v = (flgs == flgo) && (flgn != flgo);
  4120.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4121.     regs.n = flgn != 0;
  4122.     put_byte(dsta,newv);
  4123. }}}}}}}
  4124. void op_5820(UWORD opcode)
  4125. {
  4126.     ULONG srcreg = 4;
  4127.     ULONG dstreg = (opcode & 7) >> 0;
  4128. {{    ULONG src = srcreg;
  4129. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  4130. {    CPTR dsta = regs.a[dstreg];
  4131.     BYTE dst = get_byte(dsta);
  4132. {    ULONG newv = dst + src;
  4133. {    bool flgs = ((BYTE)(src)) < 0;
  4134.     bool flgo = ((BYTE)(dst)) < 0;
  4135.     bool flgn = ((BYTE)(newv)) < 0;
  4136.     regs.z = ((BYTE)(newv)) == 0;
  4137.     regs.v = (flgs == flgo) && (flgn != flgo);
  4138.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4139.     regs.n = flgn != 0;
  4140.     put_byte(dsta,newv);
  4141. }}}}}}}
  4142. void op_5828(UWORD opcode)
  4143. {
  4144.     ULONG srcreg = 4;
  4145.     ULONG dstreg = (opcode & 7) >> 0;
  4146. {{    ULONG src = srcreg;
  4147. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4148.     BYTE dst = get_byte(dsta);
  4149. {    ULONG newv = dst + src;
  4150. {    bool flgs = ((BYTE)(src)) < 0;
  4151.     bool flgo = ((BYTE)(dst)) < 0;
  4152.     bool flgn = ((BYTE)(newv)) < 0;
  4153.     regs.z = ((BYTE)(newv)) == 0;
  4154.     regs.v = (flgs == flgo) && (flgn != flgo);
  4155.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4156.     regs.n = flgn != 0;
  4157.     put_byte(dsta,newv);
  4158. }}}}}}
  4159. void op_5830(UWORD opcode)
  4160. {
  4161.     ULONG srcreg = 4;
  4162.     ULONG dstreg = (opcode & 7) >> 0;
  4163. {{    ULONG src = srcreg;
  4164. {    CPTR dsta = regs.a[dstreg];
  4165.     UWORD dstdp = nextiword();
  4166.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4167. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4168.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4169.     dsta += dstdpr;
  4170. {    BYTE dst = get_byte(dsta);
  4171. {    ULONG newv = dst + src;
  4172. {    bool flgs = ((BYTE)(src)) < 0;
  4173.     bool flgo = ((BYTE)(dst)) < 0;
  4174.     bool flgn = ((BYTE)(newv)) < 0;
  4175.     regs.z = ((BYTE)(newv)) == 0;
  4176.     regs.v = (flgs == flgo) && (flgn != flgo);
  4177.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4178.     regs.n = flgn != 0;
  4179.     put_byte(dsta,newv);
  4180. }}}}}}}}
  4181. void op_5838(UWORD opcode)
  4182. {
  4183.     ULONG srcreg = 4;
  4184. {{    ULONG src = srcreg;
  4185. {    CPTR dsta = (LONG)(WORD)nextiword();
  4186.     BYTE dst = get_byte(dsta);
  4187. {    ULONG newv = dst + src;
  4188. {    bool flgs = ((BYTE)(src)) < 0;
  4189.     bool flgo = ((BYTE)(dst)) < 0;
  4190.     bool flgn = ((BYTE)(newv)) < 0;
  4191.     regs.z = ((BYTE)(newv)) == 0;
  4192.     regs.v = (flgs == flgo) && (flgn != flgo);
  4193.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4194.     regs.n = flgn != 0;
  4195.     put_byte(dsta,newv);
  4196. }}}}}}
  4197. void op_5839(UWORD opcode)
  4198. {
  4199.     ULONG srcreg = 4;
  4200. {{    ULONG src = srcreg;
  4201. {    CPTR dsta = nextilong();
  4202.     BYTE dst = get_byte(dsta);
  4203. {    ULONG newv = dst + src;
  4204. {    bool flgs = ((BYTE)(src)) < 0;
  4205.     bool flgo = ((BYTE)(dst)) < 0;
  4206.     bool flgn = ((BYTE)(newv)) < 0;
  4207.     regs.z = ((BYTE)(newv)) == 0;
  4208.     regs.v = (flgs == flgo) && (flgn != flgo);
  4209.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  4210.     regs.n = flgn != 0;
  4211.     put_byte(dsta,newv);
  4212. }}}}}}
  4213. void op_5840(UWORD opcode)
  4214. {
  4215.     ULONG srcreg = 4;
  4216.     ULONG dstreg = (opcode & 7) >> 0;
  4217. {{    ULONG src = srcreg;
  4218. {    WORD dst = regs.d[dstreg];
  4219. {    ULONG newv = dst + src;
  4220. {    bool flgs = ((WORD)(src)) < 0;
  4221.     bool flgo = ((WORD)(dst)) < 0;
  4222.     bool flgn = ((WORD)(newv)) < 0;
  4223.     regs.z = ((WORD)(newv)) == 0;
  4224.     regs.v = (flgs == flgo) && (flgn != flgo);
  4225.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4226.     regs.n = flgn != 0;
  4227.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  4228. }}}}}}
  4229. void op_5848(UWORD opcode)
  4230. {
  4231.     ULONG srcreg = 4;
  4232.     ULONG dstreg = (opcode & 7) >> 0;
  4233. {{    ULONG src = srcreg;
  4234. {    LONG dst = regs.a[dstreg];
  4235. {    ULONG newv = dst + src;
  4236.     regs.a[dstreg] = (newv);
  4237. }}}}}
  4238. void op_5850(UWORD opcode)
  4239. {
  4240.     ULONG srcreg = 4;
  4241.     ULONG dstreg = (opcode & 7) >> 0;
  4242. {{    ULONG src = srcreg;
  4243. {    CPTR dsta = regs.a[dstreg];
  4244.     WORD dst = get_word(dsta);
  4245. {    ULONG newv = dst + src;
  4246. {    bool flgs = ((WORD)(src)) < 0;
  4247.     bool flgo = ((WORD)(dst)) < 0;
  4248.     bool flgn = ((WORD)(newv)) < 0;
  4249.     regs.z = ((WORD)(newv)) == 0;
  4250.     regs.v = (flgs == flgo) && (flgn != flgo);
  4251.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4252.     regs.n = flgn != 0;
  4253.     put_word(dsta,newv);
  4254. }}}}}}
  4255. void op_5858(UWORD opcode)
  4256. {
  4257.     ULONG srcreg = 4;
  4258.     ULONG dstreg = (opcode & 7) >> 0;
  4259. {{    ULONG src = srcreg;
  4260. {    CPTR dsta = regs.a[dstreg];
  4261.     WORD dst = get_word(dsta);
  4262. {    regs.a[dstreg] += 2;
  4263. {    ULONG newv = dst + src;
  4264. {    bool flgs = ((WORD)(src)) < 0;
  4265.     bool flgo = ((WORD)(dst)) < 0;
  4266.     bool flgn = ((WORD)(newv)) < 0;
  4267.     regs.z = ((WORD)(newv)) == 0;
  4268.     regs.v = (flgs == flgo) && (flgn != flgo);
  4269.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4270.     regs.n = flgn != 0;
  4271.     put_word(dsta,newv);
  4272. }}}}}}}
  4273. void op_5860(UWORD opcode)
  4274. {
  4275.     ULONG srcreg = 4;
  4276.     ULONG dstreg = (opcode & 7) >> 0;
  4277. {{    ULONG src = srcreg;
  4278. {    regs.a[dstreg] -= 2;
  4279. {    CPTR dsta = regs.a[dstreg];
  4280.     WORD dst = get_word(dsta);
  4281. {    ULONG newv = dst + src;
  4282. {    bool flgs = ((WORD)(src)) < 0;
  4283.     bool flgo = ((WORD)(dst)) < 0;
  4284.     bool flgn = ((WORD)(newv)) < 0;
  4285.     regs.z = ((WORD)(newv)) == 0;
  4286.     regs.v = (flgs == flgo) && (flgn != flgo);
  4287.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4288.     regs.n = flgn != 0;
  4289.     put_word(dsta,newv);
  4290. }}}}}}}
  4291. void op_5868(UWORD opcode)
  4292. {
  4293.     ULONG srcreg = 4;
  4294.     ULONG dstreg = (opcode & 7) >> 0;
  4295. {{    ULONG src = srcreg;
  4296. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4297.     WORD dst = get_word(dsta);
  4298. {    ULONG newv = dst + src;
  4299. {    bool flgs = ((WORD)(src)) < 0;
  4300.     bool flgo = ((WORD)(dst)) < 0;
  4301.     bool flgn = ((WORD)(newv)) < 0;
  4302.     regs.z = ((WORD)(newv)) == 0;
  4303.     regs.v = (flgs == flgo) && (flgn != flgo);
  4304.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4305.     regs.n = flgn != 0;
  4306.     put_word(dsta,newv);
  4307. }}}}}}
  4308. void op_5870(UWORD opcode)
  4309. {
  4310.     ULONG srcreg = 4;
  4311.     ULONG dstreg = (opcode & 7) >> 0;
  4312. {{    ULONG src = srcreg;
  4313. {    CPTR dsta = regs.a[dstreg];
  4314.     UWORD dstdp = nextiword();
  4315.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4316. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4317.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4318.     dsta += dstdpr;
  4319. {    WORD dst = get_word(dsta);
  4320. {    ULONG newv = dst + src;
  4321. {    bool flgs = ((WORD)(src)) < 0;
  4322.     bool flgo = ((WORD)(dst)) < 0;
  4323.     bool flgn = ((WORD)(newv)) < 0;
  4324.     regs.z = ((WORD)(newv)) == 0;
  4325.     regs.v = (flgs == flgo) && (flgn != flgo);
  4326.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4327.     regs.n = flgn != 0;
  4328.     put_word(dsta,newv);
  4329. }}}}}}}}
  4330. void op_5878(UWORD opcode)
  4331. {
  4332.     ULONG srcreg = 4;
  4333. {{    ULONG src = srcreg;
  4334. {    CPTR dsta = (LONG)(WORD)nextiword();
  4335.     WORD dst = get_word(dsta);
  4336. {    ULONG newv = dst + src;
  4337. {    bool flgs = ((WORD)(src)) < 0;
  4338.     bool flgo = ((WORD)(dst)) < 0;
  4339.     bool flgn = ((WORD)(newv)) < 0;
  4340.     regs.z = ((WORD)(newv)) == 0;
  4341.     regs.v = (flgs == flgo) && (flgn != flgo);
  4342.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4343.     regs.n = flgn != 0;
  4344.     put_word(dsta,newv);
  4345. }}}}}}
  4346. void op_5879(UWORD opcode)
  4347. {
  4348.     ULONG srcreg = 4;
  4349. {{    ULONG src = srcreg;
  4350. {    CPTR dsta = nextilong();
  4351.     WORD dst = get_word(dsta);
  4352. {    ULONG newv = dst + src;
  4353. {    bool flgs = ((WORD)(src)) < 0;
  4354.     bool flgo = ((WORD)(dst)) < 0;
  4355.     bool flgn = ((WORD)(newv)) < 0;
  4356.     regs.z = ((WORD)(newv)) == 0;
  4357.     regs.v = (flgs == flgo) && (flgn != flgo);
  4358.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  4359.     regs.n = flgn != 0;
  4360.     put_word(dsta,newv);
  4361. }}}}}}
  4362. void op_5880(UWORD opcode)
  4363. {
  4364.     ULONG srcreg = 4;
  4365.     ULONG dstreg = (opcode & 7) >> 0;
  4366. {{    ULONG src = srcreg;
  4367. {    LONG dst = regs.d[dstreg];
  4368. {    ULONG newv = dst + src;
  4369. {    bool flgs = ((LONG)(src)) < 0;
  4370.     bool flgo = ((LONG)(dst)) < 0;
  4371.     bool flgn = ((LONG)(newv)) < 0;
  4372.     regs.z = ((LONG)(newv)) == 0;
  4373.     regs.v = (flgs == flgo) && (flgn != flgo);
  4374.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4375.     regs.n = flgn != 0;
  4376.     regs.d[dstreg] = (newv);
  4377. }}}}}}
  4378. void op_5888(UWORD opcode)
  4379. {
  4380.     ULONG srcreg = 4;
  4381.     ULONG dstreg = (opcode & 7) >> 0;
  4382. {{    ULONG src = srcreg;
  4383. {    LONG dst = regs.a[dstreg];
  4384. {    ULONG newv = dst + src;
  4385.     regs.a[dstreg] = (newv);
  4386. }}}}}
  4387. void op_5890(UWORD opcode)
  4388. {
  4389.     ULONG srcreg = 4;
  4390.     ULONG dstreg = (opcode & 7) >> 0;
  4391. {{    ULONG src = srcreg;
  4392. {    CPTR dsta = regs.a[dstreg];
  4393.     LONG dst = get_long(dsta);
  4394. {    ULONG newv = dst + src;
  4395. {    bool flgs = ((LONG)(src)) < 0;
  4396.     bool flgo = ((LONG)(dst)) < 0;
  4397.     bool flgn = ((LONG)(newv)) < 0;
  4398.     regs.z = ((LONG)(newv)) == 0;
  4399.     regs.v = (flgs == flgo) && (flgn != flgo);
  4400.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4401.     regs.n = flgn != 0;
  4402.     put_long(dsta,newv);
  4403. }}}}}}
  4404. void op_5898(UWORD opcode)
  4405. {
  4406.     ULONG srcreg = 4;
  4407.     ULONG dstreg = (opcode & 7) >> 0;
  4408. {{    ULONG src = srcreg;
  4409. {    CPTR dsta = regs.a[dstreg];
  4410.     LONG dst = get_long(dsta);
  4411. {    regs.a[dstreg] += 4;
  4412. {    ULONG newv = dst + src;
  4413. {    bool flgs = ((LONG)(src)) < 0;
  4414.     bool flgo = ((LONG)(dst)) < 0;
  4415.     bool flgn = ((LONG)(newv)) < 0;
  4416.     regs.z = ((LONG)(newv)) == 0;
  4417.     regs.v = (flgs == flgo) && (flgn != flgo);
  4418.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4419.     regs.n = flgn != 0;
  4420.     put_long(dsta,newv);
  4421. }}}}}}}
  4422. void op_58a0(UWORD opcode)
  4423. {
  4424.     ULONG srcreg = 4;
  4425.     ULONG dstreg = (opcode & 7) >> 0;
  4426. {{    ULONG src = srcreg;
  4427. {    regs.a[dstreg] -= 4;
  4428. {    CPTR dsta = regs.a[dstreg];
  4429.     LONG dst = get_long(dsta);
  4430. {    ULONG newv = dst + src;
  4431. {    bool flgs = ((LONG)(src)) < 0;
  4432.     bool flgo = ((LONG)(dst)) < 0;
  4433.     bool flgn = ((LONG)(newv)) < 0;
  4434.     regs.z = ((LONG)(newv)) == 0;
  4435.     regs.v = (flgs == flgo) && (flgn != flgo);
  4436.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4437.     regs.n = flgn != 0;
  4438.     put_long(dsta,newv);
  4439. }}}}}}}
  4440. void op_58a8(UWORD opcode)
  4441. {
  4442.     ULONG srcreg = 4;
  4443.     ULONG dstreg = (opcode & 7) >> 0;
  4444. {{    ULONG src = srcreg;
  4445. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4446.     LONG dst = get_long(dsta);
  4447. {    ULONG newv = dst + src;
  4448. {    bool flgs = ((LONG)(src)) < 0;
  4449.     bool flgo = ((LONG)(dst)) < 0;
  4450.     bool flgn = ((LONG)(newv)) < 0;
  4451.     regs.z = ((LONG)(newv)) == 0;
  4452.     regs.v = (flgs == flgo) && (flgn != flgo);
  4453.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4454.     regs.n = flgn != 0;
  4455.     put_long(dsta,newv);
  4456. }}}}}}
  4457. void op_58b0(UWORD opcode)
  4458. {
  4459.     ULONG srcreg = 4;
  4460.     ULONG dstreg = (opcode & 7) >> 0;
  4461. {{    ULONG src = srcreg;
  4462. {    CPTR dsta = regs.a[dstreg];
  4463.     UWORD dstdp = nextiword();
  4464.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4465. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4466.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4467.     dsta += dstdpr;
  4468. {    LONG dst = get_long(dsta);
  4469. {    ULONG newv = dst + src;
  4470. {    bool flgs = ((LONG)(src)) < 0;
  4471.     bool flgo = ((LONG)(dst)) < 0;
  4472.     bool flgn = ((LONG)(newv)) < 0;
  4473.     regs.z = ((LONG)(newv)) == 0;
  4474.     regs.v = (flgs == flgo) && (flgn != flgo);
  4475.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4476.     regs.n = flgn != 0;
  4477.     put_long(dsta,newv);
  4478. }}}}}}}}
  4479. void op_58b8(UWORD opcode)
  4480. {
  4481.     ULONG srcreg = 4;
  4482. {{    ULONG src = srcreg;
  4483. {    CPTR dsta = (LONG)(WORD)nextiword();
  4484.     LONG dst = get_long(dsta);
  4485. {    ULONG newv = dst + src;
  4486. {    bool flgs = ((LONG)(src)) < 0;
  4487.     bool flgo = ((LONG)(dst)) < 0;
  4488.     bool flgn = ((LONG)(newv)) < 0;
  4489.     regs.z = ((LONG)(newv)) == 0;
  4490.     regs.v = (flgs == flgo) && (flgn != flgo);
  4491.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4492.     regs.n = flgn != 0;
  4493.     put_long(dsta,newv);
  4494. }}}}}}
  4495. void op_58b9(UWORD opcode)
  4496. {
  4497.     ULONG srcreg = 4;
  4498. {{    ULONG src = srcreg;
  4499. {    CPTR dsta = nextilong();
  4500.     LONG dst = get_long(dsta);
  4501. {    ULONG newv = dst + src;
  4502. {    bool flgs = ((LONG)(src)) < 0;
  4503.     bool flgo = ((LONG)(dst)) < 0;
  4504.     bool flgn = ((LONG)(newv)) < 0;
  4505.     regs.z = ((LONG)(newv)) == 0;
  4506.     regs.v = (flgs == flgo) && (flgn != flgo);
  4507.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  4508.     regs.n = flgn != 0;
  4509.     put_long(dsta,newv);
  4510. }}}}}}
  4511. void op_58c0(UWORD opcode)
  4512. {
  4513.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4514. {{{    int val = cctrue(8) ? 0xff : 0;
  4515.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  4516. }}}}
  4517. void op_58c8(UWORD opcode)
  4518. {
  4519.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4520. {{    WORD src = regs.d[srcreg];
  4521. {    WORD offs = nextiword();
  4522.     if (!cctrue(8)) {
  4523.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  4524.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  4525.     }
  4526. }}}}
  4527. void op_58d0(UWORD opcode)
  4528. {
  4529.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4530. {{    CPTR srca = regs.a[srcreg];
  4531. {    int val = cctrue(8) ? 0xff : 0;
  4532.     put_byte(srca,val);
  4533. }}}}
  4534. void op_58d8(UWORD opcode)
  4535. {
  4536.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4537. {{    CPTR srca = regs.a[srcreg];
  4538. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  4539. {    int val = cctrue(8) ? 0xff : 0;
  4540.     put_byte(srca,val);
  4541. }}}}}
  4542. void op_58e0(UWORD opcode)
  4543. {
  4544.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4545. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  4546. {    CPTR srca = regs.a[srcreg];
  4547. {    int val = cctrue(8) ? 0xff : 0;
  4548.     put_byte(srca,val);
  4549. }}}}}
  4550. void op_58e8(UWORD opcode)
  4551. {
  4552.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4553. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  4554. {    int val = cctrue(8) ? 0xff : 0;
  4555.     put_byte(srca,val);
  4556. }}}}
  4557. void op_58f0(UWORD opcode)
  4558. {
  4559.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  4560. {{    CPTR srca = regs.a[srcreg];
  4561.     UWORD srcdp = nextiword();
  4562.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  4563. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  4564.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  4565.     srca += srcdpr;
  4566. {    int val = cctrue(8) ? 0xff : 0;
  4567.     put_byte(srca,val);
  4568. }}}}}
  4569. void op_58f8(UWORD opcode)
  4570. {
  4571. {{    CPTR srca = (LONG)(WORD)nextiword();
  4572. {    int val = cctrue(8) ? 0xff : 0;
  4573.     put_byte(srca,val);
  4574. }}}}
  4575. void op_58f9(UWORD opcode)
  4576. {
  4577. {{    CPTR srca = nextilong();
  4578. {    int val = cctrue(8) ? 0xff : 0;
  4579.     put_byte(srca,val);
  4580. }}}}
  4581. void op_5900(UWORD opcode)
  4582. {
  4583.     ULONG srcreg = 4;
  4584.     ULONG dstreg = (opcode & 7) >> 0;
  4585. {{    ULONG src = srcreg;
  4586. {    BYTE dst = regs.d[dstreg];
  4587. {    ULONG newv = dst - src;
  4588. {    bool flgs = ((BYTE)(src)) < 0;
  4589.     bool flgo = ((BYTE)(dst)) < 0;
  4590.     bool flgn = ((BYTE)(newv)) < 0;
  4591.     regs.z = ((BYTE)(newv)) == 0;
  4592.     regs.v = (flgs != flgo) && (flgn != flgo);
  4593.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4594.     regs.n = flgn != 0;
  4595.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  4596. }}}}}}
  4597. void op_5910(UWORD opcode)
  4598. {
  4599.     ULONG srcreg = 4;
  4600.     ULONG dstreg = (opcode & 7) >> 0;
  4601. {{    ULONG src = srcreg;
  4602. {    CPTR dsta = regs.a[dstreg];
  4603.     BYTE dst = get_byte(dsta);
  4604. {    ULONG newv = dst - src;
  4605. {    bool flgs = ((BYTE)(src)) < 0;
  4606.     bool flgo = ((BYTE)(dst)) < 0;
  4607.     bool flgn = ((BYTE)(newv)) < 0;
  4608.     regs.z = ((BYTE)(newv)) == 0;
  4609.     regs.v = (flgs != flgo) && (flgn != flgo);
  4610.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4611.     regs.n = flgn != 0;
  4612.     put_byte(dsta,newv);
  4613. }}}}}}
  4614. void op_5918(UWORD opcode)
  4615. {
  4616.     ULONG srcreg = 4;
  4617.     ULONG dstreg = (opcode & 7) >> 0;
  4618. {{    ULONG src = srcreg;
  4619. {    CPTR dsta = regs.a[dstreg];
  4620.     BYTE dst = get_byte(dsta);
  4621. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  4622. {    ULONG newv = dst - src;
  4623. {    bool flgs = ((BYTE)(src)) < 0;
  4624.     bool flgo = ((BYTE)(dst)) < 0;
  4625.     bool flgn = ((BYTE)(newv)) < 0;
  4626.     regs.z = ((BYTE)(newv)) == 0;
  4627.     regs.v = (flgs != flgo) && (flgn != flgo);
  4628.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4629.     regs.n = flgn != 0;
  4630.     put_byte(dsta,newv);
  4631. }}}}}}}
  4632. void op_5920(UWORD opcode)
  4633. {
  4634.     ULONG srcreg = 4;
  4635.     ULONG dstreg = (opcode & 7) >> 0;
  4636. {{    ULONG src = srcreg;
  4637. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  4638. {    CPTR dsta = regs.a[dstreg];
  4639.     BYTE dst = get_byte(dsta);
  4640. {    ULONG newv = dst - src;
  4641. {    bool flgs = ((BYTE)(src)) < 0;
  4642.     bool flgo = ((BYTE)(dst)) < 0;
  4643.     bool flgn = ((BYTE)(newv)) < 0;
  4644.     regs.z = ((BYTE)(newv)) == 0;
  4645.     regs.v = (flgs != flgo) && (flgn != flgo);
  4646.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4647.     regs.n = flgn != 0;
  4648.     put_byte(dsta,newv);
  4649. }}}}}}}
  4650. void op_5928(UWORD opcode)
  4651. {
  4652.     ULONG srcreg = 4;
  4653.     ULONG dstreg = (opcode & 7) >> 0;
  4654. {{    ULONG src = srcreg;
  4655. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4656.     BYTE dst = get_byte(dsta);
  4657. {    ULONG newv = dst - src;
  4658. {    bool flgs = ((BYTE)(src)) < 0;
  4659.     bool flgo = ((BYTE)(dst)) < 0;
  4660.     bool flgn = ((BYTE)(newv)) < 0;
  4661.     regs.z = ((BYTE)(newv)) == 0;
  4662.     regs.v = (flgs != flgo) && (flgn != flgo);
  4663.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4664.     regs.n = flgn != 0;
  4665.     put_byte(dsta,newv);
  4666. }}}}}}
  4667. void op_5930(UWORD opcode)
  4668. {
  4669.     ULONG srcreg = 4;
  4670.     ULONG dstreg = (opcode & 7) >> 0;
  4671. {{    ULONG src = srcreg;
  4672. {    CPTR dsta = regs.a[dstreg];
  4673.     UWORD dstdp = nextiword();
  4674.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4675. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4676.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4677.     dsta += dstdpr;
  4678. {    BYTE dst = get_byte(dsta);
  4679. {    ULONG newv = dst - src;
  4680. {    bool flgs = ((BYTE)(src)) < 0;
  4681.     bool flgo = ((BYTE)(dst)) < 0;
  4682.     bool flgn = ((BYTE)(newv)) < 0;
  4683.     regs.z = ((BYTE)(newv)) == 0;
  4684.     regs.v = (flgs != flgo) && (flgn != flgo);
  4685.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4686.     regs.n = flgn != 0;
  4687.     put_byte(dsta,newv);
  4688. }}}}}}}}
  4689. void op_5938(UWORD opcode)
  4690. {
  4691.     ULONG srcreg = 4;
  4692. {{    ULONG src = srcreg;
  4693. {    CPTR dsta = (LONG)(WORD)nextiword();
  4694.     BYTE dst = get_byte(dsta);
  4695. {    ULONG newv = dst - src;
  4696. {    bool flgs = ((BYTE)(src)) < 0;
  4697.     bool flgo = ((BYTE)(dst)) < 0;
  4698.     bool flgn = ((BYTE)(newv)) < 0;
  4699.     regs.z = ((BYTE)(newv)) == 0;
  4700.     regs.v = (flgs != flgo) && (flgn != flgo);
  4701.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4702.     regs.n = flgn != 0;
  4703.     put_byte(dsta,newv);
  4704. }}}}}}
  4705. void op_5939(UWORD opcode)
  4706. {
  4707.     ULONG srcreg = 4;
  4708. {{    ULONG src = srcreg;
  4709. {    CPTR dsta = nextilong();
  4710.     BYTE dst = get_byte(dsta);
  4711. {    ULONG newv = dst - src;
  4712. {    bool flgs = ((BYTE)(src)) < 0;
  4713.     bool flgo = ((BYTE)(dst)) < 0;
  4714.     bool flgn = ((BYTE)(newv)) < 0;
  4715.     regs.z = ((BYTE)(newv)) == 0;
  4716.     regs.v = (flgs != flgo) && (flgn != flgo);
  4717.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  4718.     regs.n = flgn != 0;
  4719.     put_byte(dsta,newv);
  4720. }}}}}}
  4721. void op_5940(UWORD opcode)
  4722. {
  4723.     ULONG srcreg = 4;
  4724.     ULONG dstreg = (opcode & 7) >> 0;
  4725. {{    ULONG src = srcreg;
  4726. {    WORD dst = regs.d[dstreg];
  4727. {    ULONG newv = dst - src;
  4728. {    bool flgs = ((WORD)(src)) < 0;
  4729.     bool flgo = ((WORD)(dst)) < 0;
  4730.     bool flgn = ((WORD)(newv)) < 0;
  4731.     regs.z = ((WORD)(newv)) == 0;
  4732.     regs.v = (flgs != flgo) && (flgn != flgo);
  4733.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4734.     regs.n = flgn != 0;
  4735.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  4736. }}}}}}
  4737. void op_5948(UWORD opcode)
  4738. {
  4739.     ULONG srcreg = 4;
  4740.     ULONG dstreg = (opcode & 7) >> 0;
  4741. {{    ULONG src = srcreg;
  4742. {    LONG dst = regs.a[dstreg];
  4743. {    ULONG newv = dst - src;
  4744.     regs.a[dstreg] = (newv);
  4745. }}}}}
  4746. void op_5950(UWORD opcode)
  4747. {
  4748.     ULONG srcreg = 4;
  4749.     ULONG dstreg = (opcode & 7) >> 0;
  4750. {{    ULONG src = srcreg;
  4751. {    CPTR dsta = regs.a[dstreg];
  4752.     WORD dst = get_word(dsta);
  4753. {    ULONG newv = dst - src;
  4754. {    bool flgs = ((WORD)(src)) < 0;
  4755.     bool flgo = ((WORD)(dst)) < 0;
  4756.     bool flgn = ((WORD)(newv)) < 0;
  4757.     regs.z = ((WORD)(newv)) == 0;
  4758.     regs.v = (flgs != flgo) && (flgn != flgo);
  4759.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4760.     regs.n = flgn != 0;
  4761.     put_word(dsta,newv);
  4762. }}}}}}
  4763. void op_5958(UWORD opcode)
  4764. {
  4765.     ULONG srcreg = 4;
  4766.     ULONG dstreg = (opcode & 7) >> 0;
  4767. {{    ULONG src = srcreg;
  4768. {    CPTR dsta = regs.a[dstreg];
  4769.     WORD dst = get_word(dsta);
  4770. {    regs.a[dstreg] += 2;
  4771. {    ULONG newv = dst - src;
  4772. {    bool flgs = ((WORD)(src)) < 0;
  4773.     bool flgo = ((WORD)(dst)) < 0;
  4774.     bool flgn = ((WORD)(newv)) < 0;
  4775.     regs.z = ((WORD)(newv)) == 0;
  4776.     regs.v = (flgs != flgo) && (flgn != flgo);
  4777.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4778.     regs.n = flgn != 0;
  4779.     put_word(dsta,newv);
  4780. }}}}}}}
  4781. void op_5960(UWORD opcode)
  4782. {
  4783.     ULONG srcreg = 4;
  4784.     ULONG dstreg = (opcode & 7) >> 0;
  4785. {{    ULONG src = srcreg;
  4786. {    regs.a[dstreg] -= 2;
  4787. {    CPTR dsta = regs.a[dstreg];
  4788.     WORD dst = get_word(dsta);
  4789. {    ULONG newv = dst - src;
  4790. {    bool flgs = ((WORD)(src)) < 0;
  4791.     bool flgo = ((WORD)(dst)) < 0;
  4792.     bool flgn = ((WORD)(newv)) < 0;
  4793.     regs.z = ((WORD)(newv)) == 0;
  4794.     regs.v = (flgs != flgo) && (flgn != flgo);
  4795.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4796.     regs.n = flgn != 0;
  4797.     put_word(dsta,newv);
  4798. }}}}}}}
  4799. void op_5968(UWORD opcode)
  4800. {
  4801.     ULONG srcreg = 4;
  4802.     ULONG dstreg = (opcode & 7) >> 0;
  4803. {{    ULONG src = srcreg;
  4804. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4805.     WORD dst = get_word(dsta);
  4806. {    ULONG newv = dst - src;
  4807. {    bool flgs = ((WORD)(src)) < 0;
  4808.     bool flgo = ((WORD)(dst)) < 0;
  4809.     bool flgn = ((WORD)(newv)) < 0;
  4810.     regs.z = ((WORD)(newv)) == 0;
  4811.     regs.v = (flgs != flgo) && (flgn != flgo);
  4812.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4813.     regs.n = flgn != 0;
  4814.     put_word(dsta,newv);
  4815. }}}}}}
  4816. void op_5970(UWORD opcode)
  4817. {
  4818.     ULONG srcreg = 4;
  4819.     ULONG dstreg = (opcode & 7) >> 0;
  4820. {{    ULONG src = srcreg;
  4821. {    CPTR dsta = regs.a[dstreg];
  4822.     UWORD dstdp = nextiword();
  4823.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4824. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4825.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4826.     dsta += dstdpr;
  4827. {    WORD dst = get_word(dsta);
  4828. {    ULONG newv = dst - src;
  4829. {    bool flgs = ((WORD)(src)) < 0;
  4830.     bool flgo = ((WORD)(dst)) < 0;
  4831.     bool flgn = ((WORD)(newv)) < 0;
  4832.     regs.z = ((WORD)(newv)) == 0;
  4833.     regs.v = (flgs != flgo) && (flgn != flgo);
  4834.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4835.     regs.n = flgn != 0;
  4836.     put_word(dsta,newv);
  4837. }}}}}}}}
  4838. void op_5978(UWORD opcode)
  4839. {
  4840.     ULONG srcreg = 4;
  4841. {{    ULONG src = srcreg;
  4842. {    CPTR dsta = (LONG)(WORD)nextiword();
  4843.     WORD dst = get_word(dsta);
  4844. {    ULONG newv = dst - src;
  4845. {    bool flgs = ((WORD)(src)) < 0;
  4846.     bool flgo = ((WORD)(dst)) < 0;
  4847.     bool flgn = ((WORD)(newv)) < 0;
  4848.     regs.z = ((WORD)(newv)) == 0;
  4849.     regs.v = (flgs != flgo) && (flgn != flgo);
  4850.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4851.     regs.n = flgn != 0;
  4852.     put_word(dsta,newv);
  4853. }}}}}}
  4854. void op_5979(UWORD opcode)
  4855. {
  4856.     ULONG srcreg = 4;
  4857. {{    ULONG src = srcreg;
  4858. {    CPTR dsta = nextilong();
  4859.     WORD dst = get_word(dsta);
  4860. {    ULONG newv = dst - src;
  4861. {    bool flgs = ((WORD)(src)) < 0;
  4862.     bool flgo = ((WORD)(dst)) < 0;
  4863.     bool flgn = ((WORD)(newv)) < 0;
  4864.     regs.z = ((WORD)(newv)) == 0;
  4865.     regs.v = (flgs != flgo) && (flgn != flgo);
  4866.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  4867.     regs.n = flgn != 0;
  4868.     put_word(dsta,newv);
  4869. }}}}}}
  4870. void op_5980(UWORD opcode)
  4871. {
  4872.     ULONG srcreg = 4;
  4873.     ULONG dstreg = (opcode & 7) >> 0;
  4874. {{    ULONG src = srcreg;
  4875. {    LONG dst = regs.d[dstreg];
  4876. {    ULONG newv = dst - src;
  4877. {    bool flgs = ((LONG)(src)) < 0;
  4878.     bool flgo = ((LONG)(dst)) < 0;
  4879.     bool flgn = ((LONG)(newv)) < 0;
  4880.     regs.z = ((LONG)(newv)) == 0;
  4881.     regs.v = (flgs != flgo) && (flgn != flgo);
  4882.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4883.     regs.n = flgn != 0;
  4884.     regs.d[dstreg] = (newv);
  4885. }}}}}}
  4886. void op_5988(UWORD opcode)
  4887. {
  4888.     ULONG srcreg = 4;
  4889.     ULONG dstreg = (opcode & 7) >> 0;
  4890. {{    ULONG src = srcreg;
  4891. {    LONG dst = regs.a[dstreg];
  4892. {    ULONG newv = dst - src;
  4893.     regs.a[dstreg] = (newv);
  4894. }}}}}
  4895. void op_5990(UWORD opcode)
  4896. {
  4897.     ULONG srcreg = 4;
  4898.     ULONG dstreg = (opcode & 7) >> 0;
  4899. {{    ULONG src = srcreg;
  4900. {    CPTR dsta = regs.a[dstreg];
  4901.     LONG dst = get_long(dsta);
  4902. {    ULONG newv = dst - src;
  4903. {    bool flgs = ((LONG)(src)) < 0;
  4904.     bool flgo = ((LONG)(dst)) < 0;
  4905.     bool flgn = ((LONG)(newv)) < 0;
  4906.     regs.z = ((LONG)(newv)) == 0;
  4907.     regs.v = (flgs != flgo) && (flgn != flgo);
  4908.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4909.     regs.n = flgn != 0;
  4910.     put_long(dsta,newv);
  4911. }}}}}}
  4912. void op_5998(UWORD opcode)
  4913. {
  4914.     ULONG srcreg = 4;
  4915.     ULONG dstreg = (opcode & 7) >> 0;
  4916. {{    ULONG src = srcreg;
  4917. {    CPTR dsta = regs.a[dstreg];
  4918.     LONG dst = get_long(dsta);
  4919. {    regs.a[dstreg] += 4;
  4920. {    ULONG newv = dst - src;
  4921. {    bool flgs = ((LONG)(src)) < 0;
  4922.     bool flgo = ((LONG)(dst)) < 0;
  4923.     bool flgn = ((LONG)(newv)) < 0;
  4924.     regs.z = ((LONG)(newv)) == 0;
  4925.     regs.v = (flgs != flgo) && (flgn != flgo);
  4926.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4927.     regs.n = flgn != 0;
  4928.     put_long(dsta,newv);
  4929. }}}}}}}
  4930. void op_59a0(UWORD opcode)
  4931. {
  4932.     ULONG srcreg = 4;
  4933.     ULONG dstreg = (opcode & 7) >> 0;
  4934. {{    ULONG src = srcreg;
  4935. {    regs.a[dstreg] -= 4;
  4936. {    CPTR dsta = regs.a[dstreg];
  4937.     LONG dst = get_long(dsta);
  4938. {    ULONG newv = dst - src;
  4939. {    bool flgs = ((LONG)(src)) < 0;
  4940.     bool flgo = ((LONG)(dst)) < 0;
  4941.     bool flgn = ((LONG)(newv)) < 0;
  4942.     regs.z = ((LONG)(newv)) == 0;
  4943.     regs.v = (flgs != flgo) && (flgn != flgo);
  4944.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4945.     regs.n = flgn != 0;
  4946.     put_long(dsta,newv);
  4947. }}}}}}}
  4948. void op_59a8(UWORD opcode)
  4949. {
  4950.     ULONG srcreg = 4;
  4951.     ULONG dstreg = (opcode & 7) >> 0;
  4952. {{    ULONG src = srcreg;
  4953. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  4954.     LONG dst = get_long(dsta);
  4955. {    ULONG newv = dst - src;
  4956. {    bool flgs = ((LONG)(src)) < 0;
  4957.     bool flgo = ((LONG)(dst)) < 0;
  4958.     bool flgn = ((LONG)(newv)) < 0;
  4959.     regs.z = ((LONG)(newv)) == 0;
  4960.     regs.v = (flgs != flgo) && (flgn != flgo);
  4961.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4962.     regs.n = flgn != 0;
  4963.     put_long(dsta,newv);
  4964. }}}}}}
  4965. void op_59b0(UWORD opcode)
  4966. {
  4967.     ULONG srcreg = 4;
  4968.     ULONG dstreg = (opcode & 7) >> 0;
  4969. {{    ULONG src = srcreg;
  4970. {    CPTR dsta = regs.a[dstreg];
  4971.     UWORD dstdp = nextiword();
  4972.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  4973. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  4974.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  4975.     dsta += dstdpr;
  4976. {    LONG dst = get_long(dsta);
  4977. {    ULONG newv = dst - src;
  4978. {    bool flgs = ((LONG)(src)) < 0;
  4979.     bool flgo = ((LONG)(dst)) < 0;
  4980.     bool flgn = ((LONG)(newv)) < 0;
  4981.     regs.z = ((LONG)(newv)) == 0;
  4982.     regs.v = (flgs != flgo) && (flgn != flgo);
  4983.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  4984.     regs.n = flgn != 0;
  4985.     put_long(dsta,newv);
  4986. }}}}}}}}
  4987. void op_59b8(UWORD opcode)
  4988. {
  4989.     ULONG srcreg = 4;
  4990. {{    ULONG src = srcreg;
  4991. {    CPTR dsta = (LONG)(WORD)nextiword();
  4992.     LONG dst = get_long(dsta);
  4993. {    ULONG newv = dst - src;
  4994. {    bool flgs = ((LONG)(src)) < 0;
  4995.     bool flgo = ((LONG)(dst)) < 0;
  4996.     bool flgn = ((LONG)(newv)) < 0;
  4997.     regs.z = ((LONG)(newv)) == 0;
  4998.     regs.v = (flgs != flgo) && (flgn != flgo);
  4999.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5000.     regs.n = flgn != 0;
  5001.     put_long(dsta,newv);
  5002. }}}}}}
  5003. void op_59b9(UWORD opcode)
  5004. {
  5005.     ULONG srcreg = 4;
  5006. {{    ULONG src = srcreg;
  5007. {    CPTR dsta = nextilong();
  5008.     LONG dst = get_long(dsta);
  5009. {    ULONG newv = dst - src;
  5010. {    bool flgs = ((LONG)(src)) < 0;
  5011.     bool flgo = ((LONG)(dst)) < 0;
  5012.     bool flgn = ((LONG)(newv)) < 0;
  5013.     regs.z = ((LONG)(newv)) == 0;
  5014.     regs.v = (flgs != flgo) && (flgn != flgo);
  5015.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5016.     regs.n = flgn != 0;
  5017.     put_long(dsta,newv);
  5018. }}}}}}
  5019. void op_59c0(UWORD opcode)
  5020. {
  5021.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5022. {{{    int val = cctrue(9) ? 0xff : 0;
  5023.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  5024. }}}}
  5025. void op_59c8(UWORD opcode)
  5026. {
  5027.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5028. {{    WORD src = regs.d[srcreg];
  5029. {    WORD offs = nextiword();
  5030.     if (!cctrue(9)) {
  5031.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  5032.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  5033.     }
  5034. }}}}
  5035. void op_59d0(UWORD opcode)
  5036. {
  5037.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5038. {{    CPTR srca = regs.a[srcreg];
  5039. {    int val = cctrue(9) ? 0xff : 0;
  5040.     put_byte(srca,val);
  5041. }}}}
  5042. void op_59d8(UWORD opcode)
  5043. {
  5044.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5045. {{    CPTR srca = regs.a[srcreg];
  5046. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  5047. {    int val = cctrue(9) ? 0xff : 0;
  5048.     put_byte(srca,val);
  5049. }}}}}
  5050. void op_59e0(UWORD opcode)
  5051. {
  5052.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5053. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  5054. {    CPTR srca = regs.a[srcreg];
  5055. {    int val = cctrue(9) ? 0xff : 0;
  5056.     put_byte(srca,val);
  5057. }}}}}
  5058. void op_59e8(UWORD opcode)
  5059. {
  5060.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5061. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  5062. {    int val = cctrue(9) ? 0xff : 0;
  5063.     put_byte(srca,val);
  5064. }}}}
  5065. void op_59f0(UWORD opcode)
  5066. {
  5067.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5068. {{    CPTR srca = regs.a[srcreg];
  5069.     UWORD srcdp = nextiword();
  5070.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  5071. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  5072.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  5073.     srca += srcdpr;
  5074. {    int val = cctrue(9) ? 0xff : 0;
  5075.     put_byte(srca,val);
  5076. }}}}}
  5077. void op_59f8(UWORD opcode)
  5078. {
  5079. {{    CPTR srca = (LONG)(WORD)nextiword();
  5080. {    int val = cctrue(9) ? 0xff : 0;
  5081.     put_byte(srca,val);
  5082. }}}}
  5083. void op_59f9(UWORD opcode)
  5084. {
  5085. {{    CPTR srca = nextilong();
  5086. {    int val = cctrue(9) ? 0xff : 0;
  5087.     put_byte(srca,val);
  5088. }}}}
  5089. void op_5a00(UWORD opcode)
  5090. {
  5091.     ULONG srcreg = 5;
  5092.     ULONG dstreg = (opcode & 7) >> 0;
  5093. {{    ULONG src = srcreg;
  5094. {    BYTE dst = regs.d[dstreg];
  5095. {    ULONG newv = dst + src;
  5096. {    bool flgs = ((BYTE)(src)) < 0;
  5097.     bool flgo = ((BYTE)(dst)) < 0;
  5098.     bool flgn = ((BYTE)(newv)) < 0;
  5099.     regs.z = ((BYTE)(newv)) == 0;
  5100.     regs.v = (flgs == flgo) && (flgn != flgo);
  5101.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5102.     regs.n = flgn != 0;
  5103.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  5104. }}}}}}
  5105. void op_5a10(UWORD opcode)
  5106. {
  5107.     ULONG srcreg = 5;
  5108.     ULONG dstreg = (opcode & 7) >> 0;
  5109. {{    ULONG src = srcreg;
  5110. {    CPTR dsta = regs.a[dstreg];
  5111.     BYTE dst = get_byte(dsta);
  5112. {    ULONG newv = dst + src;
  5113. {    bool flgs = ((BYTE)(src)) < 0;
  5114.     bool flgo = ((BYTE)(dst)) < 0;
  5115.     bool flgn = ((BYTE)(newv)) < 0;
  5116.     regs.z = ((BYTE)(newv)) == 0;
  5117.     regs.v = (flgs == flgo) && (flgn != flgo);
  5118.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5119.     regs.n = flgn != 0;
  5120.     put_byte(dsta,newv);
  5121. }}}}}}
  5122. void op_5a18(UWORD opcode)
  5123. {
  5124.     ULONG srcreg = 5;
  5125.     ULONG dstreg = (opcode & 7) >> 0;
  5126. {{    ULONG src = srcreg;
  5127. {    CPTR dsta = regs.a[dstreg];
  5128.     BYTE dst = get_byte(dsta);
  5129. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  5130. {    ULONG newv = dst + src;
  5131. {    bool flgs = ((BYTE)(src)) < 0;
  5132.     bool flgo = ((BYTE)(dst)) < 0;
  5133.     bool flgn = ((BYTE)(newv)) < 0;
  5134.     regs.z = ((BYTE)(newv)) == 0;
  5135.     regs.v = (flgs == flgo) && (flgn != flgo);
  5136.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5137.     regs.n = flgn != 0;
  5138.     put_byte(dsta,newv);
  5139. }}}}}}}
  5140. void op_5a20(UWORD opcode)
  5141. {
  5142.     ULONG srcreg = 5;
  5143.     ULONG dstreg = (opcode & 7) >> 0;
  5144. {{    ULONG src = srcreg;
  5145. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  5146. {    CPTR dsta = regs.a[dstreg];
  5147.     BYTE dst = get_byte(dsta);
  5148. {    ULONG newv = dst + src;
  5149. {    bool flgs = ((BYTE)(src)) < 0;
  5150.     bool flgo = ((BYTE)(dst)) < 0;
  5151.     bool flgn = ((BYTE)(newv)) < 0;
  5152.     regs.z = ((BYTE)(newv)) == 0;
  5153.     regs.v = (flgs == flgo) && (flgn != flgo);
  5154.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5155.     regs.n = flgn != 0;
  5156.     put_byte(dsta,newv);
  5157. }}}}}}}
  5158. void op_5a28(UWORD opcode)
  5159. {
  5160.     ULONG srcreg = 5;
  5161.     ULONG dstreg = (opcode & 7) >> 0;
  5162. {{    ULONG src = srcreg;
  5163. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5164.     BYTE dst = get_byte(dsta);
  5165. {    ULONG newv = dst + src;
  5166. {    bool flgs = ((BYTE)(src)) < 0;
  5167.     bool flgo = ((BYTE)(dst)) < 0;
  5168.     bool flgn = ((BYTE)(newv)) < 0;
  5169.     regs.z = ((BYTE)(newv)) == 0;
  5170.     regs.v = (flgs == flgo) && (flgn != flgo);
  5171.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5172.     regs.n = flgn != 0;
  5173.     put_byte(dsta,newv);
  5174. }}}}}}
  5175. void op_5a30(UWORD opcode)
  5176. {
  5177.     ULONG srcreg = 5;
  5178.     ULONG dstreg = (opcode & 7) >> 0;
  5179. {{    ULONG src = srcreg;
  5180. {    CPTR dsta = regs.a[dstreg];
  5181.     UWORD dstdp = nextiword();
  5182.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5183. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5184.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5185.     dsta += dstdpr;
  5186. {    BYTE dst = get_byte(dsta);
  5187. {    ULONG newv = dst + src;
  5188. {    bool flgs = ((BYTE)(src)) < 0;
  5189.     bool flgo = ((BYTE)(dst)) < 0;
  5190.     bool flgn = ((BYTE)(newv)) < 0;
  5191.     regs.z = ((BYTE)(newv)) == 0;
  5192.     regs.v = (flgs == flgo) && (flgn != flgo);
  5193.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5194.     regs.n = flgn != 0;
  5195.     put_byte(dsta,newv);
  5196. }}}}}}}}
  5197. void op_5a38(UWORD opcode)
  5198. {
  5199.     ULONG srcreg = 5;
  5200. {{    ULONG src = srcreg;
  5201. {    CPTR dsta = (LONG)(WORD)nextiword();
  5202.     BYTE dst = get_byte(dsta);
  5203. {    ULONG newv = dst + src;
  5204. {    bool flgs = ((BYTE)(src)) < 0;
  5205.     bool flgo = ((BYTE)(dst)) < 0;
  5206.     bool flgn = ((BYTE)(newv)) < 0;
  5207.     regs.z = ((BYTE)(newv)) == 0;
  5208.     regs.v = (flgs == flgo) && (flgn != flgo);
  5209.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5210.     regs.n = flgn != 0;
  5211.     put_byte(dsta,newv);
  5212. }}}}}}
  5213. void op_5a39(UWORD opcode)
  5214. {
  5215.     ULONG srcreg = 5;
  5216. {{    ULONG src = srcreg;
  5217. {    CPTR dsta = nextilong();
  5218.     BYTE dst = get_byte(dsta);
  5219. {    ULONG newv = dst + src;
  5220. {    bool flgs = ((BYTE)(src)) < 0;
  5221.     bool flgo = ((BYTE)(dst)) < 0;
  5222.     bool flgn = ((BYTE)(newv)) < 0;
  5223.     regs.z = ((BYTE)(newv)) == 0;
  5224.     regs.v = (flgs == flgo) && (flgn != flgo);
  5225.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  5226.     regs.n = flgn != 0;
  5227.     put_byte(dsta,newv);
  5228. }}}}}}
  5229. void op_5a40(UWORD opcode)
  5230. {
  5231.     ULONG srcreg = 5;
  5232.     ULONG dstreg = (opcode & 7) >> 0;
  5233. {{    ULONG src = srcreg;
  5234. {    WORD dst = regs.d[dstreg];
  5235. {    ULONG newv = dst + src;
  5236. {    bool flgs = ((WORD)(src)) < 0;
  5237.     bool flgo = ((WORD)(dst)) < 0;
  5238.     bool flgn = ((WORD)(newv)) < 0;
  5239.     regs.z = ((WORD)(newv)) == 0;
  5240.     regs.v = (flgs == flgo) && (flgn != flgo);
  5241.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5242.     regs.n = flgn != 0;
  5243.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  5244. }}}}}}
  5245. void op_5a48(UWORD opcode)
  5246. {
  5247.     ULONG srcreg = 5;
  5248.     ULONG dstreg = (opcode & 7) >> 0;
  5249. {{    ULONG src = srcreg;
  5250. {    LONG dst = regs.a[dstreg];
  5251. {    ULONG newv = dst + src;
  5252.     regs.a[dstreg] = (newv);
  5253. }}}}}
  5254. void op_5a50(UWORD opcode)
  5255. {
  5256.     ULONG srcreg = 5;
  5257.     ULONG dstreg = (opcode & 7) >> 0;
  5258. {{    ULONG src = srcreg;
  5259. {    CPTR dsta = regs.a[dstreg];
  5260.     WORD dst = get_word(dsta);
  5261. {    ULONG newv = dst + src;
  5262. {    bool flgs = ((WORD)(src)) < 0;
  5263.     bool flgo = ((WORD)(dst)) < 0;
  5264.     bool flgn = ((WORD)(newv)) < 0;
  5265.     regs.z = ((WORD)(newv)) == 0;
  5266.     regs.v = (flgs == flgo) && (flgn != flgo);
  5267.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5268.     regs.n = flgn != 0;
  5269.     put_word(dsta,newv);
  5270. }}}}}}
  5271. void op_5a58(UWORD opcode)
  5272. {
  5273.     ULONG srcreg = 5;
  5274.     ULONG dstreg = (opcode & 7) >> 0;
  5275. {{    ULONG src = srcreg;
  5276. {    CPTR dsta = regs.a[dstreg];
  5277.     WORD dst = get_word(dsta);
  5278. {    regs.a[dstreg] += 2;
  5279. {    ULONG newv = dst + src;
  5280. {    bool flgs = ((WORD)(src)) < 0;
  5281.     bool flgo = ((WORD)(dst)) < 0;
  5282.     bool flgn = ((WORD)(newv)) < 0;
  5283.     regs.z = ((WORD)(newv)) == 0;
  5284.     regs.v = (flgs == flgo) && (flgn != flgo);
  5285.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5286.     regs.n = flgn != 0;
  5287.     put_word(dsta,newv);
  5288. }}}}}}}
  5289. void op_5a60(UWORD opcode)
  5290. {
  5291.     ULONG srcreg = 5;
  5292.     ULONG dstreg = (opcode & 7) >> 0;
  5293. {{    ULONG src = srcreg;
  5294. {    regs.a[dstreg] -= 2;
  5295. {    CPTR dsta = regs.a[dstreg];
  5296.     WORD dst = get_word(dsta);
  5297. {    ULONG newv = dst + src;
  5298. {    bool flgs = ((WORD)(src)) < 0;
  5299.     bool flgo = ((WORD)(dst)) < 0;
  5300.     bool flgn = ((WORD)(newv)) < 0;
  5301.     regs.z = ((WORD)(newv)) == 0;
  5302.     regs.v = (flgs == flgo) && (flgn != flgo);
  5303.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5304.     regs.n = flgn != 0;
  5305.     put_word(dsta,newv);
  5306. }}}}}}}
  5307. void op_5a68(UWORD opcode)
  5308. {
  5309.     ULONG srcreg = 5;
  5310.     ULONG dstreg = (opcode & 7) >> 0;
  5311. {{    ULONG src = srcreg;
  5312. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5313.     WORD dst = get_word(dsta);
  5314. {    ULONG newv = dst + src;
  5315. {    bool flgs = ((WORD)(src)) < 0;
  5316.     bool flgo = ((WORD)(dst)) < 0;
  5317.     bool flgn = ((WORD)(newv)) < 0;
  5318.     regs.z = ((WORD)(newv)) == 0;
  5319.     regs.v = (flgs == flgo) && (flgn != flgo);
  5320.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5321.     regs.n = flgn != 0;
  5322.     put_word(dsta,newv);
  5323. }}}}}}
  5324. void op_5a70(UWORD opcode)
  5325. {
  5326.     ULONG srcreg = 5;
  5327.     ULONG dstreg = (opcode & 7) >> 0;
  5328. {{    ULONG src = srcreg;
  5329. {    CPTR dsta = regs.a[dstreg];
  5330.     UWORD dstdp = nextiword();
  5331.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5332. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5333.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5334.     dsta += dstdpr;
  5335. {    WORD dst = get_word(dsta);
  5336. {    ULONG newv = dst + src;
  5337. {    bool flgs = ((WORD)(src)) < 0;
  5338.     bool flgo = ((WORD)(dst)) < 0;
  5339.     bool flgn = ((WORD)(newv)) < 0;
  5340.     regs.z = ((WORD)(newv)) == 0;
  5341.     regs.v = (flgs == flgo) && (flgn != flgo);
  5342.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5343.     regs.n = flgn != 0;
  5344.     put_word(dsta,newv);
  5345. }}}}}}}}
  5346. void op_5a78(UWORD opcode)
  5347. {
  5348.     ULONG srcreg = 5;
  5349. {{    ULONG src = srcreg;
  5350. {    CPTR dsta = (LONG)(WORD)nextiword();
  5351.     WORD dst = get_word(dsta);
  5352. {    ULONG newv = dst + src;
  5353. {    bool flgs = ((WORD)(src)) < 0;
  5354.     bool flgo = ((WORD)(dst)) < 0;
  5355.     bool flgn = ((WORD)(newv)) < 0;
  5356.     regs.z = ((WORD)(newv)) == 0;
  5357.     regs.v = (flgs == flgo) && (flgn != flgo);
  5358.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5359.     regs.n = flgn != 0;
  5360.     put_word(dsta,newv);
  5361. }}}}}}
  5362. void op_5a79(UWORD opcode)
  5363. {
  5364.     ULONG srcreg = 5;
  5365. {{    ULONG src = srcreg;
  5366. {    CPTR dsta = nextilong();
  5367.     WORD dst = get_word(dsta);
  5368. {    ULONG newv = dst + src;
  5369. {    bool flgs = ((WORD)(src)) < 0;
  5370.     bool flgo = ((WORD)(dst)) < 0;
  5371.     bool flgn = ((WORD)(newv)) < 0;
  5372.     regs.z = ((WORD)(newv)) == 0;
  5373.     regs.v = (flgs == flgo) && (flgn != flgo);
  5374.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  5375.     regs.n = flgn != 0;
  5376.     put_word(dsta,newv);
  5377. }}}}}}
  5378. void op_5a80(UWORD opcode)
  5379. {
  5380.     ULONG srcreg = 5;
  5381.     ULONG dstreg = (opcode & 7) >> 0;
  5382. {{    ULONG src = srcreg;
  5383. {    LONG dst = regs.d[dstreg];
  5384. {    ULONG newv = dst + src;
  5385. {    bool flgs = ((LONG)(src)) < 0;
  5386.     bool flgo = ((LONG)(dst)) < 0;
  5387.     bool flgn = ((LONG)(newv)) < 0;
  5388.     regs.z = ((LONG)(newv)) == 0;
  5389.     regs.v = (flgs == flgo) && (flgn != flgo);
  5390.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5391.     regs.n = flgn != 0;
  5392.     regs.d[dstreg] = (newv);
  5393. }}}}}}
  5394. void op_5a88(UWORD opcode)
  5395. {
  5396.     ULONG srcreg = 5;
  5397.     ULONG dstreg = (opcode & 7) >> 0;
  5398. {{    ULONG src = srcreg;
  5399. {    LONG dst = regs.a[dstreg];
  5400. {    ULONG newv = dst + src;
  5401.     regs.a[dstreg] = (newv);
  5402. }}}}}
  5403. void op_5a90(UWORD opcode)
  5404. {
  5405.     ULONG srcreg = 5;
  5406.     ULONG dstreg = (opcode & 7) >> 0;
  5407. {{    ULONG src = srcreg;
  5408. {    CPTR dsta = regs.a[dstreg];
  5409.     LONG dst = get_long(dsta);
  5410. {    ULONG newv = dst + src;
  5411. {    bool flgs = ((LONG)(src)) < 0;
  5412.     bool flgo = ((LONG)(dst)) < 0;
  5413.     bool flgn = ((LONG)(newv)) < 0;
  5414.     regs.z = ((LONG)(newv)) == 0;
  5415.     regs.v = (flgs == flgo) && (flgn != flgo);
  5416.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5417.     regs.n = flgn != 0;
  5418.     put_long(dsta,newv);
  5419. }}}}}}
  5420. void op_5a98(UWORD opcode)
  5421. {
  5422.     ULONG srcreg = 5;
  5423.     ULONG dstreg = (opcode & 7) >> 0;
  5424. {{    ULONG src = srcreg;
  5425. {    CPTR dsta = regs.a[dstreg];
  5426.     LONG dst = get_long(dsta);
  5427. {    regs.a[dstreg] += 4;
  5428. {    ULONG newv = dst + src;
  5429. {    bool flgs = ((LONG)(src)) < 0;
  5430.     bool flgo = ((LONG)(dst)) < 0;
  5431.     bool flgn = ((LONG)(newv)) < 0;
  5432.     regs.z = ((LONG)(newv)) == 0;
  5433.     regs.v = (flgs == flgo) && (flgn != flgo);
  5434.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5435.     regs.n = flgn != 0;
  5436.     put_long(dsta,newv);
  5437. }}}}}}}
  5438. void op_5aa0(UWORD opcode)
  5439. {
  5440.     ULONG srcreg = 5;
  5441.     ULONG dstreg = (opcode & 7) >> 0;
  5442. {{    ULONG src = srcreg;
  5443. {    regs.a[dstreg] -= 4;
  5444. {    CPTR dsta = regs.a[dstreg];
  5445.     LONG dst = get_long(dsta);
  5446. {    ULONG newv = dst + src;
  5447. {    bool flgs = ((LONG)(src)) < 0;
  5448.     bool flgo = ((LONG)(dst)) < 0;
  5449.     bool flgn = ((LONG)(newv)) < 0;
  5450.     regs.z = ((LONG)(newv)) == 0;
  5451.     regs.v = (flgs == flgo) && (flgn != flgo);
  5452.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5453.     regs.n = flgn != 0;
  5454.     put_long(dsta,newv);
  5455. }}}}}}}
  5456. void op_5aa8(UWORD opcode)
  5457. {
  5458.     ULONG srcreg = 5;
  5459.     ULONG dstreg = (opcode & 7) >> 0;
  5460. {{    ULONG src = srcreg;
  5461. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5462.     LONG dst = get_long(dsta);
  5463. {    ULONG newv = dst + src;
  5464. {    bool flgs = ((LONG)(src)) < 0;
  5465.     bool flgo = ((LONG)(dst)) < 0;
  5466.     bool flgn = ((LONG)(newv)) < 0;
  5467.     regs.z = ((LONG)(newv)) == 0;
  5468.     regs.v = (flgs == flgo) && (flgn != flgo);
  5469.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5470.     regs.n = flgn != 0;
  5471.     put_long(dsta,newv);
  5472. }}}}}}
  5473. void op_5ab0(UWORD opcode)
  5474. {
  5475.     ULONG srcreg = 5;
  5476.     ULONG dstreg = (opcode & 7) >> 0;
  5477. {{    ULONG src = srcreg;
  5478. {    CPTR dsta = regs.a[dstreg];
  5479.     UWORD dstdp = nextiword();
  5480.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5481. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5482.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5483.     dsta += dstdpr;
  5484. {    LONG dst = get_long(dsta);
  5485. {    ULONG newv = dst + src;
  5486. {    bool flgs = ((LONG)(src)) < 0;
  5487.     bool flgo = ((LONG)(dst)) < 0;
  5488.     bool flgn = ((LONG)(newv)) < 0;
  5489.     regs.z = ((LONG)(newv)) == 0;
  5490.     regs.v = (flgs == flgo) && (flgn != flgo);
  5491.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5492.     regs.n = flgn != 0;
  5493.     put_long(dsta,newv);
  5494. }}}}}}}}
  5495. void op_5ab8(UWORD opcode)
  5496. {
  5497.     ULONG srcreg = 5;
  5498. {{    ULONG src = srcreg;
  5499. {    CPTR dsta = (LONG)(WORD)nextiword();
  5500.     LONG dst = get_long(dsta);
  5501. {    ULONG newv = dst + src;
  5502. {    bool flgs = ((LONG)(src)) < 0;
  5503.     bool flgo = ((LONG)(dst)) < 0;
  5504.     bool flgn = ((LONG)(newv)) < 0;
  5505.     regs.z = ((LONG)(newv)) == 0;
  5506.     regs.v = (flgs == flgo) && (flgn != flgo);
  5507.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5508.     regs.n = flgn != 0;
  5509.     put_long(dsta,newv);
  5510. }}}}}}
  5511. void op_5ab9(UWORD opcode)
  5512. {
  5513.     ULONG srcreg = 5;
  5514. {{    ULONG src = srcreg;
  5515. {    CPTR dsta = nextilong();
  5516.     LONG dst = get_long(dsta);
  5517. {    ULONG newv = dst + src;
  5518. {    bool flgs = ((LONG)(src)) < 0;
  5519.     bool flgo = ((LONG)(dst)) < 0;
  5520.     bool flgn = ((LONG)(newv)) < 0;
  5521.     regs.z = ((LONG)(newv)) == 0;
  5522.     regs.v = (flgs == flgo) && (flgn != flgo);
  5523.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  5524.     regs.n = flgn != 0;
  5525.     put_long(dsta,newv);
  5526. }}}}}}
  5527. void op_5ac0(UWORD opcode)
  5528. {
  5529.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5530. {{{    int val = cctrue(10) ? 0xff : 0;
  5531.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  5532. }}}}
  5533. void op_5ac8(UWORD opcode)
  5534. {
  5535.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5536. {{    WORD src = regs.d[srcreg];
  5537. {    WORD offs = nextiword();
  5538.     if (!cctrue(10)) {
  5539.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  5540.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  5541.     }
  5542. }}}}
  5543. void op_5ad0(UWORD opcode)
  5544. {
  5545.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5546. {{    CPTR srca = regs.a[srcreg];
  5547. {    int val = cctrue(10) ? 0xff : 0;
  5548.     put_byte(srca,val);
  5549. }}}}
  5550. void op_5ad8(UWORD opcode)
  5551. {
  5552.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5553. {{    CPTR srca = regs.a[srcreg];
  5554. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  5555. {    int val = cctrue(10) ? 0xff : 0;
  5556.     put_byte(srca,val);
  5557. }}}}}
  5558. void op_5ae0(UWORD opcode)
  5559. {
  5560.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5561. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  5562. {    CPTR srca = regs.a[srcreg];
  5563. {    int val = cctrue(10) ? 0xff : 0;
  5564.     put_byte(srca,val);
  5565. }}}}}
  5566. void op_5ae8(UWORD opcode)
  5567. {
  5568.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5569. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  5570. {    int val = cctrue(10) ? 0xff : 0;
  5571.     put_byte(srca,val);
  5572. }}}}
  5573. void op_5af0(UWORD opcode)
  5574. {
  5575.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  5576. {{    CPTR srca = regs.a[srcreg];
  5577.     UWORD srcdp = nextiword();
  5578.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  5579. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  5580.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  5581.     srca += srcdpr;
  5582. {    int val = cctrue(10) ? 0xff : 0;
  5583.     put_byte(srca,val);
  5584. }}}}}
  5585. void op_5af8(UWORD opcode)
  5586. {
  5587. {{    CPTR srca = (LONG)(WORD)nextiword();
  5588. {    int val = cctrue(10) ? 0xff : 0;
  5589.     put_byte(srca,val);
  5590. }}}}
  5591. void op_5af9(UWORD opcode)
  5592. {
  5593. {{    CPTR srca = nextilong();
  5594. {    int val = cctrue(10) ? 0xff : 0;
  5595.     put_byte(srca,val);
  5596. }}}}
  5597. void op_5b00(UWORD opcode)
  5598. {
  5599.     ULONG srcreg = 5;
  5600.     ULONG dstreg = (opcode & 7) >> 0;
  5601. {{    ULONG src = srcreg;
  5602. {    BYTE dst = regs.d[dstreg];
  5603. {    ULONG newv = dst - src;
  5604. {    bool flgs = ((BYTE)(src)) < 0;
  5605.     bool flgo = ((BYTE)(dst)) < 0;
  5606.     bool flgn = ((BYTE)(newv)) < 0;
  5607.     regs.z = ((BYTE)(newv)) == 0;
  5608.     regs.v = (flgs != flgo) && (flgn != flgo);
  5609.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5610.     regs.n = flgn != 0;
  5611.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  5612. }}}}}}
  5613. void op_5b10(UWORD opcode)
  5614. {
  5615.     ULONG srcreg = 5;
  5616.     ULONG dstreg = (opcode & 7) >> 0;
  5617. {{    ULONG src = srcreg;
  5618. {    CPTR dsta = regs.a[dstreg];
  5619.     BYTE dst = get_byte(dsta);
  5620. {    ULONG newv = dst - src;
  5621. {    bool flgs = ((BYTE)(src)) < 0;
  5622.     bool flgo = ((BYTE)(dst)) < 0;
  5623.     bool flgn = ((BYTE)(newv)) < 0;
  5624.     regs.z = ((BYTE)(newv)) == 0;
  5625.     regs.v = (flgs != flgo) && (flgn != flgo);
  5626.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5627.     regs.n = flgn != 0;
  5628.     put_byte(dsta,newv);
  5629. }}}}}}
  5630. void op_5b18(UWORD opcode)
  5631. {
  5632.     ULONG srcreg = 5;
  5633.     ULONG dstreg = (opcode & 7) >> 0;
  5634. {{    ULONG src = srcreg;
  5635. {    CPTR dsta = regs.a[dstreg];
  5636.     BYTE dst = get_byte(dsta);
  5637. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  5638. {    ULONG newv = dst - src;
  5639. {    bool flgs = ((BYTE)(src)) < 0;
  5640.     bool flgo = ((BYTE)(dst)) < 0;
  5641.     bool flgn = ((BYTE)(newv)) < 0;
  5642.     regs.z = ((BYTE)(newv)) == 0;
  5643.     regs.v = (flgs != flgo) && (flgn != flgo);
  5644.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5645.     regs.n = flgn != 0;
  5646.     put_byte(dsta,newv);
  5647. }}}}}}}
  5648. void op_5b20(UWORD opcode)
  5649. {
  5650.     ULONG srcreg = 5;
  5651.     ULONG dstreg = (opcode & 7) >> 0;
  5652. {{    ULONG src = srcreg;
  5653. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  5654. {    CPTR dsta = regs.a[dstreg];
  5655.     BYTE dst = get_byte(dsta);
  5656. {    ULONG newv = dst - src;
  5657. {    bool flgs = ((BYTE)(src)) < 0;
  5658.     bool flgo = ((BYTE)(dst)) < 0;
  5659.     bool flgn = ((BYTE)(newv)) < 0;
  5660.     regs.z = ((BYTE)(newv)) == 0;
  5661.     regs.v = (flgs != flgo) && (flgn != flgo);
  5662.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5663.     regs.n = flgn != 0;
  5664.     put_byte(dsta,newv);
  5665. }}}}}}}
  5666. void op_5b28(UWORD opcode)
  5667. {
  5668.     ULONG srcreg = 5;
  5669.     ULONG dstreg = (opcode & 7) >> 0;
  5670. {{    ULONG src = srcreg;
  5671. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5672.     BYTE dst = get_byte(dsta);
  5673. {    ULONG newv = dst - src;
  5674. {    bool flgs = ((BYTE)(src)) < 0;
  5675.     bool flgo = ((BYTE)(dst)) < 0;
  5676.     bool flgn = ((BYTE)(newv)) < 0;
  5677.     regs.z = ((BYTE)(newv)) == 0;
  5678.     regs.v = (flgs != flgo) && (flgn != flgo);
  5679.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5680.     regs.n = flgn != 0;
  5681.     put_byte(dsta,newv);
  5682. }}}}}}
  5683. void op_5b30(UWORD opcode)
  5684. {
  5685.     ULONG srcreg = 5;
  5686.     ULONG dstreg = (opcode & 7) >> 0;
  5687. {{    ULONG src = srcreg;
  5688. {    CPTR dsta = regs.a[dstreg];
  5689.     UWORD dstdp = nextiword();
  5690.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5691. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5692.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5693.     dsta += dstdpr;
  5694. {    BYTE dst = get_byte(dsta);
  5695. {    ULONG newv = dst - src;
  5696. {    bool flgs = ((BYTE)(src)) < 0;
  5697.     bool flgo = ((BYTE)(dst)) < 0;
  5698.     bool flgn = ((BYTE)(newv)) < 0;
  5699.     regs.z = ((BYTE)(newv)) == 0;
  5700.     regs.v = (flgs != flgo) && (flgn != flgo);
  5701.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5702.     regs.n = flgn != 0;
  5703.     put_byte(dsta,newv);
  5704. }}}}}}}}
  5705. void op_5b38(UWORD opcode)
  5706. {
  5707.     ULONG srcreg = 5;
  5708. {{    ULONG src = srcreg;
  5709. {    CPTR dsta = (LONG)(WORD)nextiword();
  5710.     BYTE dst = get_byte(dsta);
  5711. {    ULONG newv = dst - src;
  5712. {    bool flgs = ((BYTE)(src)) < 0;
  5713.     bool flgo = ((BYTE)(dst)) < 0;
  5714.     bool flgn = ((BYTE)(newv)) < 0;
  5715.     regs.z = ((BYTE)(newv)) == 0;
  5716.     regs.v = (flgs != flgo) && (flgn != flgo);
  5717.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5718.     regs.n = flgn != 0;
  5719.     put_byte(dsta,newv);
  5720. }}}}}}
  5721. void op_5b39(UWORD opcode)
  5722. {
  5723.     ULONG srcreg = 5;
  5724. {{    ULONG src = srcreg;
  5725. {    CPTR dsta = nextilong();
  5726.     BYTE dst = get_byte(dsta);
  5727. {    ULONG newv = dst - src;
  5728. {    bool flgs = ((BYTE)(src)) < 0;
  5729.     bool flgo = ((BYTE)(dst)) < 0;
  5730.     bool flgn = ((BYTE)(newv)) < 0;
  5731.     regs.z = ((BYTE)(newv)) == 0;
  5732.     regs.v = (flgs != flgo) && (flgn != flgo);
  5733.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  5734.     regs.n = flgn != 0;
  5735.     put_byte(dsta,newv);
  5736. }}}}}}
  5737. void op_5b40(UWORD opcode)
  5738. {
  5739.     ULONG srcreg = 5;
  5740.     ULONG dstreg = (opcode & 7) >> 0;
  5741. {{    ULONG src = srcreg;
  5742. {    WORD dst = regs.d[dstreg];
  5743. {    ULONG newv = dst - src;
  5744. {    bool flgs = ((WORD)(src)) < 0;
  5745.     bool flgo = ((WORD)(dst)) < 0;
  5746.     bool flgn = ((WORD)(newv)) < 0;
  5747.     regs.z = ((WORD)(newv)) == 0;
  5748.     regs.v = (flgs != flgo) && (flgn != flgo);
  5749.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5750.     regs.n = flgn != 0;
  5751.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  5752. }}}}}}
  5753. void op_5b48(UWORD opcode)
  5754. {
  5755.     ULONG srcreg = 5;
  5756.     ULONG dstreg = (opcode & 7) >> 0;
  5757. {{    ULONG src = srcreg;
  5758. {    LONG dst = regs.a[dstreg];
  5759. {    ULONG newv = dst - src;
  5760.     regs.a[dstreg] = (newv);
  5761. }}}}}
  5762. void op_5b50(UWORD opcode)
  5763. {
  5764.     ULONG srcreg = 5;
  5765.     ULONG dstreg = (opcode & 7) >> 0;
  5766. {{    ULONG src = srcreg;
  5767. {    CPTR dsta = regs.a[dstreg];
  5768.     WORD dst = get_word(dsta);
  5769. {    ULONG newv = dst - src;
  5770. {    bool flgs = ((WORD)(src)) < 0;
  5771.     bool flgo = ((WORD)(dst)) < 0;
  5772.     bool flgn = ((WORD)(newv)) < 0;
  5773.     regs.z = ((WORD)(newv)) == 0;
  5774.     regs.v = (flgs != flgo) && (flgn != flgo);
  5775.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5776.     regs.n = flgn != 0;
  5777.     put_word(dsta,newv);
  5778. }}}}}}
  5779. void op_5b58(UWORD opcode)
  5780. {
  5781.     ULONG srcreg = 5;
  5782.     ULONG dstreg = (opcode & 7) >> 0;
  5783. {{    ULONG src = srcreg;
  5784. {    CPTR dsta = regs.a[dstreg];
  5785.     WORD dst = get_word(dsta);
  5786. {    regs.a[dstreg] += 2;
  5787. {    ULONG newv = dst - src;
  5788. {    bool flgs = ((WORD)(src)) < 0;
  5789.     bool flgo = ((WORD)(dst)) < 0;
  5790.     bool flgn = ((WORD)(newv)) < 0;
  5791.     regs.z = ((WORD)(newv)) == 0;
  5792.     regs.v = (flgs != flgo) && (flgn != flgo);
  5793.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5794.     regs.n = flgn != 0;
  5795.     put_word(dsta,newv);
  5796. }}}}}}}
  5797. void op_5b60(UWORD opcode)
  5798. {
  5799.     ULONG srcreg = 5;
  5800.     ULONG dstreg = (opcode & 7) >> 0;
  5801. {{    ULONG src = srcreg;
  5802. {    regs.a[dstreg] -= 2;
  5803. {    CPTR dsta = regs.a[dstreg];
  5804.     WORD dst = get_word(dsta);
  5805. {    ULONG newv = dst - src;
  5806. {    bool flgs = ((WORD)(src)) < 0;
  5807.     bool flgo = ((WORD)(dst)) < 0;
  5808.     bool flgn = ((WORD)(newv)) < 0;
  5809.     regs.z = ((WORD)(newv)) == 0;
  5810.     regs.v = (flgs != flgo) && (flgn != flgo);
  5811.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5812.     regs.n = flgn != 0;
  5813.     put_word(dsta,newv);
  5814. }}}}}}}
  5815. void op_5b68(UWORD opcode)
  5816. {
  5817.     ULONG srcreg = 5;
  5818.     ULONG dstreg = (opcode & 7) >> 0;
  5819. {{    ULONG src = srcreg;
  5820. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5821.     WORD dst = get_word(dsta);
  5822. {    ULONG newv = dst - src;
  5823. {    bool flgs = ((WORD)(src)) < 0;
  5824.     bool flgo = ((WORD)(dst)) < 0;
  5825.     bool flgn = ((WORD)(newv)) < 0;
  5826.     regs.z = ((WORD)(newv)) == 0;
  5827.     regs.v = (flgs != flgo) && (flgn != flgo);
  5828.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5829.     regs.n = flgn != 0;
  5830.     put_word(dsta,newv);
  5831. }}}}}}
  5832. void op_5b70(UWORD opcode)
  5833. {
  5834.     ULONG srcreg = 5;
  5835.     ULONG dstreg = (opcode & 7) >> 0;
  5836. {{    ULONG src = srcreg;
  5837. {    CPTR dsta = regs.a[dstreg];
  5838.     UWORD dstdp = nextiword();
  5839.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5840. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5841.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5842.     dsta += dstdpr;
  5843. {    WORD dst = get_word(dsta);
  5844. {    ULONG newv = dst - src;
  5845. {    bool flgs = ((WORD)(src)) < 0;
  5846.     bool flgo = ((WORD)(dst)) < 0;
  5847.     bool flgn = ((WORD)(newv)) < 0;
  5848.     regs.z = ((WORD)(newv)) == 0;
  5849.     regs.v = (flgs != flgo) && (flgn != flgo);
  5850.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5851.     regs.n = flgn != 0;
  5852.     put_word(dsta,newv);
  5853. }}}}}}}}
  5854. void op_5b78(UWORD opcode)
  5855. {
  5856.     ULONG srcreg = 5;
  5857. {{    ULONG src = srcreg;
  5858. {    CPTR dsta = (LONG)(WORD)nextiword();
  5859.     WORD dst = get_word(dsta);
  5860. {    ULONG newv = dst - src;
  5861. {    bool flgs = ((WORD)(src)) < 0;
  5862.     bool flgo = ((WORD)(dst)) < 0;
  5863.     bool flgn = ((WORD)(newv)) < 0;
  5864.     regs.z = ((WORD)(newv)) == 0;
  5865.     regs.v = (flgs != flgo) && (flgn != flgo);
  5866.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5867.     regs.n = flgn != 0;
  5868.     put_word(dsta,newv);
  5869. }}}}}}
  5870. void op_5b79(UWORD opcode)
  5871. {
  5872.     ULONG srcreg = 5;
  5873. {{    ULONG src = srcreg;
  5874. {    CPTR dsta = nextilong();
  5875.     WORD dst = get_word(dsta);
  5876. {    ULONG newv = dst - src;
  5877. {    bool flgs = ((WORD)(src)) < 0;
  5878.     bool flgo = ((WORD)(dst)) < 0;
  5879.     bool flgn = ((WORD)(newv)) < 0;
  5880.     regs.z = ((WORD)(newv)) == 0;
  5881.     regs.v = (flgs != flgo) && (flgn != flgo);
  5882.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  5883.     regs.n = flgn != 0;
  5884.     put_word(dsta,newv);
  5885. }}}}}}
  5886. void op_5b80(UWORD opcode)
  5887. {
  5888.     ULONG srcreg = 5;
  5889.     ULONG dstreg = (opcode & 7) >> 0;
  5890. {{    ULONG src = srcreg;
  5891. {    LONG dst = regs.d[dstreg];
  5892. {    ULONG newv = dst - src;
  5893. {    bool flgs = ((LONG)(src)) < 0;
  5894.     bool flgo = ((LONG)(dst)) < 0;
  5895.     bool flgn = ((LONG)(newv)) < 0;
  5896.     regs.z = ((LONG)(newv)) == 0;
  5897.     regs.v = (flgs != flgo) && (flgn != flgo);
  5898.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5899.     regs.n = flgn != 0;
  5900.     regs.d[dstreg] = (newv);
  5901. }}}}}}
  5902. void op_5b88(UWORD opcode)
  5903. {
  5904.     ULONG srcreg = 5;
  5905.     ULONG dstreg = (opcode & 7) >> 0;
  5906. {{    ULONG src = srcreg;
  5907. {    LONG dst = regs.a[dstreg];
  5908. {    ULONG newv = dst - src;
  5909.     regs.a[dstreg] = (newv);
  5910. }}}}}
  5911. void op_5b90(UWORD opcode)
  5912. {
  5913.     ULONG srcreg = 5;
  5914.     ULONG dstreg = (opcode & 7) >> 0;
  5915. {{    ULONG src = srcreg;
  5916. {    CPTR dsta = regs.a[dstreg];
  5917.     LONG dst = get_long(dsta);
  5918. {    ULONG newv = dst - src;
  5919. {    bool flgs = ((LONG)(src)) < 0;
  5920.     bool flgo = ((LONG)(dst)) < 0;
  5921.     bool flgn = ((LONG)(newv)) < 0;
  5922.     regs.z = ((LONG)(newv)) == 0;
  5923.     regs.v = (flgs != flgo) && (flgn != flgo);
  5924.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5925.     regs.n = flgn != 0;
  5926.     put_long(dsta,newv);
  5927. }}}}}}
  5928. void op_5b98(UWORD opcode)
  5929. {
  5930.     ULONG srcreg = 5;
  5931.     ULONG dstreg = (opcode & 7) >> 0;
  5932. {{    ULONG src = srcreg;
  5933. {    CPTR dsta = regs.a[dstreg];
  5934.     LONG dst = get_long(dsta);
  5935. {    regs.a[dstreg] += 4;
  5936. {    ULONG newv = dst - src;
  5937. {    bool flgs = ((LONG)(src)) < 0;
  5938.     bool flgo = ((LONG)(dst)) < 0;
  5939.     bool flgn = ((LONG)(newv)) < 0;
  5940.     regs.z = ((LONG)(newv)) == 0;
  5941.     regs.v = (flgs != flgo) && (flgn != flgo);
  5942.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5943.     regs.n = flgn != 0;
  5944.     put_long(dsta,newv);
  5945. }}}}}}}
  5946. void op_5ba0(UWORD opcode)
  5947. {
  5948.     ULONG srcreg = 5;
  5949.     ULONG dstreg = (opcode & 7) >> 0;
  5950. {{    ULONG src = srcreg;
  5951. {    regs.a[dstreg] -= 4;
  5952. {    CPTR dsta = regs.a[dstreg];
  5953.     LONG dst = get_long(dsta);
  5954. {    ULONG newv = dst - src;
  5955. {    bool flgs = ((LONG)(src)) < 0;
  5956.     bool flgo = ((LONG)(dst)) < 0;
  5957.     bool flgn = ((LONG)(newv)) < 0;
  5958.     regs.z = ((LONG)(newv)) == 0;
  5959.     regs.v = (flgs != flgo) && (flgn != flgo);
  5960.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5961.     regs.n = flgn != 0;
  5962.     put_long(dsta,newv);
  5963. }}}}}}}
  5964. void op_5ba8(UWORD opcode)
  5965. {
  5966.     ULONG srcreg = 5;
  5967.     ULONG dstreg = (opcode & 7) >> 0;
  5968. {{    ULONG src = srcreg;
  5969. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  5970.     LONG dst = get_long(dsta);
  5971. {    ULONG newv = dst - src;
  5972. {    bool flgs = ((LONG)(src)) < 0;
  5973.     bool flgo = ((LONG)(dst)) < 0;
  5974.     bool flgn = ((LONG)(newv)) < 0;
  5975.     regs.z = ((LONG)(newv)) == 0;
  5976.     regs.v = (flgs != flgo) && (flgn != flgo);
  5977.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  5978.     regs.n = flgn != 0;
  5979.     put_long(dsta,newv);
  5980. }}}}}}
  5981. void op_5bb0(UWORD opcode)
  5982. {
  5983.     ULONG srcreg = 5;
  5984.     ULONG dstreg = (opcode & 7) >> 0;
  5985. {{    ULONG src = srcreg;
  5986. {    CPTR dsta = regs.a[dstreg];
  5987.     UWORD dstdp = nextiword();
  5988.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  5989. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  5990.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  5991.     dsta += dstdpr;
  5992. {    LONG dst = get_long(dsta);
  5993. {    ULONG newv = dst - src;
  5994. {    bool flgs = ((LONG)(src)) < 0;
  5995.     bool flgo = ((LONG)(dst)) < 0;
  5996.     bool flgn = ((LONG)(newv)) < 0;
  5997.     regs.z = ((LONG)(newv)) == 0;
  5998.     regs.v = (flgs != flgo) && (flgn != flgo);
  5999.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6000.     regs.n = flgn != 0;
  6001.     put_long(dsta,newv);
  6002. }}}}}}}}
  6003. void op_5bb8(UWORD opcode)
  6004. {
  6005.     ULONG srcreg = 5;
  6006. {{    ULONG src = srcreg;
  6007. {    CPTR dsta = (LONG)(WORD)nextiword();
  6008.     LONG dst = get_long(dsta);
  6009. {    ULONG newv = dst - src;
  6010. {    bool flgs = ((LONG)(src)) < 0;
  6011.     bool flgo = ((LONG)(dst)) < 0;
  6012.     bool flgn = ((LONG)(newv)) < 0;
  6013.     regs.z = ((LONG)(newv)) == 0;
  6014.     regs.v = (flgs != flgo) && (flgn != flgo);
  6015.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6016.     regs.n = flgn != 0;
  6017.     put_long(dsta,newv);
  6018. }}}}}}
  6019. void op_5bb9(UWORD opcode)
  6020. {
  6021.     ULONG srcreg = 5;
  6022. {{    ULONG src = srcreg;
  6023. {    CPTR dsta = nextilong();
  6024.     LONG dst = get_long(dsta);
  6025. {    ULONG newv = dst - src;
  6026. {    bool flgs = ((LONG)(src)) < 0;
  6027.     bool flgo = ((LONG)(dst)) < 0;
  6028.     bool flgn = ((LONG)(newv)) < 0;
  6029.     regs.z = ((LONG)(newv)) == 0;
  6030.     regs.v = (flgs != flgo) && (flgn != flgo);
  6031.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6032.     regs.n = flgn != 0;
  6033.     put_long(dsta,newv);
  6034. }}}}}}
  6035. void op_5bc0(UWORD opcode)
  6036. {
  6037.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6038. {{{    int val = cctrue(11) ? 0xff : 0;
  6039.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  6040. }}}}
  6041. void op_5bc8(UWORD opcode)
  6042. {
  6043.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6044. {{    WORD src = regs.d[srcreg];
  6045. {    WORD offs = nextiword();
  6046.     if (!cctrue(11)) {
  6047.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  6048.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  6049.     }
  6050. }}}}
  6051. void op_5bd0(UWORD opcode)
  6052. {
  6053.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6054. {{    CPTR srca = regs.a[srcreg];
  6055. {    int val = cctrue(11) ? 0xff : 0;
  6056.     put_byte(srca,val);
  6057. }}}}
  6058. void op_5bd8(UWORD opcode)
  6059. {
  6060.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6061. {{    CPTR srca = regs.a[srcreg];
  6062. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  6063. {    int val = cctrue(11) ? 0xff : 0;
  6064.     put_byte(srca,val);
  6065. }}}}}
  6066. void op_5be0(UWORD opcode)
  6067. {
  6068.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6069. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  6070. {    CPTR srca = regs.a[srcreg];
  6071. {    int val = cctrue(11) ? 0xff : 0;
  6072.     put_byte(srca,val);
  6073. }}}}}
  6074. void op_5be8(UWORD opcode)
  6075. {
  6076.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6077. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  6078. {    int val = cctrue(11) ? 0xff : 0;
  6079.     put_byte(srca,val);
  6080. }}}}
  6081. void op_5bf0(UWORD opcode)
  6082. {
  6083.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6084. {{    CPTR srca = regs.a[srcreg];
  6085.     UWORD srcdp = nextiword();
  6086.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  6087. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  6088.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  6089.     srca += srcdpr;
  6090. {    int val = cctrue(11) ? 0xff : 0;
  6091.     put_byte(srca,val);
  6092. }}}}}
  6093. void op_5bf8(UWORD opcode)
  6094. {
  6095. {{    CPTR srca = (LONG)(WORD)nextiword();
  6096. {    int val = cctrue(11) ? 0xff : 0;
  6097.     put_byte(srca,val);
  6098. }}}}
  6099. void op_5bf9(UWORD opcode)
  6100. {
  6101. {{    CPTR srca = nextilong();
  6102. {    int val = cctrue(11) ? 0xff : 0;
  6103.     put_byte(srca,val);
  6104. }}}}
  6105. void op_5c00(UWORD opcode)
  6106. {
  6107.     ULONG srcreg = 6;
  6108.     ULONG dstreg = (opcode & 7) >> 0;
  6109. {{    ULONG src = srcreg;
  6110. {    BYTE dst = regs.d[dstreg];
  6111. {    ULONG newv = dst + src;
  6112. {    bool flgs = ((BYTE)(src)) < 0;
  6113.     bool flgo = ((BYTE)(dst)) < 0;
  6114.     bool flgn = ((BYTE)(newv)) < 0;
  6115.     regs.z = ((BYTE)(newv)) == 0;
  6116.     regs.v = (flgs == flgo) && (flgn != flgo);
  6117.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6118.     regs.n = flgn != 0;
  6119.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  6120. }}}}}}
  6121. void op_5c10(UWORD opcode)
  6122. {
  6123.     ULONG srcreg = 6;
  6124.     ULONG dstreg = (opcode & 7) >> 0;
  6125. {{    ULONG src = srcreg;
  6126. {    CPTR dsta = regs.a[dstreg];
  6127.     BYTE dst = get_byte(dsta);
  6128. {    ULONG newv = dst + src;
  6129. {    bool flgs = ((BYTE)(src)) < 0;
  6130.     bool flgo = ((BYTE)(dst)) < 0;
  6131.     bool flgn = ((BYTE)(newv)) < 0;
  6132.     regs.z = ((BYTE)(newv)) == 0;
  6133.     regs.v = (flgs == flgo) && (flgn != flgo);
  6134.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6135.     regs.n = flgn != 0;
  6136.     put_byte(dsta,newv);
  6137. }}}}}}
  6138. void op_5c18(UWORD opcode)
  6139. {
  6140.     ULONG srcreg = 6;
  6141.     ULONG dstreg = (opcode & 7) >> 0;
  6142. {{    ULONG src = srcreg;
  6143. {    CPTR dsta = regs.a[dstreg];
  6144.     BYTE dst = get_byte(dsta);
  6145. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  6146. {    ULONG newv = dst + src;
  6147. {    bool flgs = ((BYTE)(src)) < 0;
  6148.     bool flgo = ((BYTE)(dst)) < 0;
  6149.     bool flgn = ((BYTE)(newv)) < 0;
  6150.     regs.z = ((BYTE)(newv)) == 0;
  6151.     regs.v = (flgs == flgo) && (flgn != flgo);
  6152.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6153.     regs.n = flgn != 0;
  6154.     put_byte(dsta,newv);
  6155. }}}}}}}
  6156. void op_5c20(UWORD opcode)
  6157. {
  6158.     ULONG srcreg = 6;
  6159.     ULONG dstreg = (opcode & 7) >> 0;
  6160. {{    ULONG src = srcreg;
  6161. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  6162. {    CPTR dsta = regs.a[dstreg];
  6163.     BYTE dst = get_byte(dsta);
  6164. {    ULONG newv = dst + src;
  6165. {    bool flgs = ((BYTE)(src)) < 0;
  6166.     bool flgo = ((BYTE)(dst)) < 0;
  6167.     bool flgn = ((BYTE)(newv)) < 0;
  6168.     regs.z = ((BYTE)(newv)) == 0;
  6169.     regs.v = (flgs == flgo) && (flgn != flgo);
  6170.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6171.     regs.n = flgn != 0;
  6172.     put_byte(dsta,newv);
  6173. }}}}}}}
  6174. void op_5c28(UWORD opcode)
  6175. {
  6176.     ULONG srcreg = 6;
  6177.     ULONG dstreg = (opcode & 7) >> 0;
  6178. {{    ULONG src = srcreg;
  6179. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6180.     BYTE dst = get_byte(dsta);
  6181. {    ULONG newv = dst + src;
  6182. {    bool flgs = ((BYTE)(src)) < 0;
  6183.     bool flgo = ((BYTE)(dst)) < 0;
  6184.     bool flgn = ((BYTE)(newv)) < 0;
  6185.     regs.z = ((BYTE)(newv)) == 0;
  6186.     regs.v = (flgs == flgo) && (flgn != flgo);
  6187.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6188.     regs.n = flgn != 0;
  6189.     put_byte(dsta,newv);
  6190. }}}}}}
  6191. void op_5c30(UWORD opcode)
  6192. {
  6193.     ULONG srcreg = 6;
  6194.     ULONG dstreg = (opcode & 7) >> 0;
  6195. {{    ULONG src = srcreg;
  6196. {    CPTR dsta = regs.a[dstreg];
  6197.     UWORD dstdp = nextiword();
  6198.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  6199. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  6200.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  6201.     dsta += dstdpr;
  6202. {    BYTE dst = get_byte(dsta);
  6203. {    ULONG newv = dst + src;
  6204. {    bool flgs = ((BYTE)(src)) < 0;
  6205.     bool flgo = ((BYTE)(dst)) < 0;
  6206.     bool flgn = ((BYTE)(newv)) < 0;
  6207.     regs.z = ((BYTE)(newv)) == 0;
  6208.     regs.v = (flgs == flgo) && (flgn != flgo);
  6209.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6210.     regs.n = flgn != 0;
  6211.     put_byte(dsta,newv);
  6212. }}}}}}}}
  6213. void op_5c38(UWORD opcode)
  6214. {
  6215.     ULONG srcreg = 6;
  6216. {{    ULONG src = srcreg;
  6217. {    CPTR dsta = (LONG)(WORD)nextiword();
  6218.     BYTE dst = get_byte(dsta);
  6219. {    ULONG newv = dst + src;
  6220. {    bool flgs = ((BYTE)(src)) < 0;
  6221.     bool flgo = ((BYTE)(dst)) < 0;
  6222.     bool flgn = ((BYTE)(newv)) < 0;
  6223.     regs.z = ((BYTE)(newv)) == 0;
  6224.     regs.v = (flgs == flgo) && (flgn != flgo);
  6225.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6226.     regs.n = flgn != 0;
  6227.     put_byte(dsta,newv);
  6228. }}}}}}
  6229. void op_5c39(UWORD opcode)
  6230. {
  6231.     ULONG srcreg = 6;
  6232. {{    ULONG src = srcreg;
  6233. {    CPTR dsta = nextilong();
  6234.     BYTE dst = get_byte(dsta);
  6235. {    ULONG newv = dst + src;
  6236. {    bool flgs = ((BYTE)(src)) < 0;
  6237.     bool flgo = ((BYTE)(dst)) < 0;
  6238.     bool flgn = ((BYTE)(newv)) < 0;
  6239.     regs.z = ((BYTE)(newv)) == 0;
  6240.     regs.v = (flgs == flgo) && (flgn != flgo);
  6241.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  6242.     regs.n = flgn != 0;
  6243.     put_byte(dsta,newv);
  6244. }}}}}}
  6245. void op_5c40(UWORD opcode)
  6246. {
  6247.     ULONG srcreg = 6;
  6248.     ULONG dstreg = (opcode & 7) >> 0;
  6249. {{    ULONG src = srcreg;
  6250. {    WORD dst = regs.d[dstreg];
  6251. {    ULONG newv = dst + src;
  6252. {    bool flgs = ((WORD)(src)) < 0;
  6253.     bool flgo = ((WORD)(dst)) < 0;
  6254.     bool flgn = ((WORD)(newv)) < 0;
  6255.     regs.z = ((WORD)(newv)) == 0;
  6256.     regs.v = (flgs == flgo) && (flgn != flgo);
  6257.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6258.     regs.n = flgn != 0;
  6259.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  6260. }}}}}}
  6261. void op_5c48(UWORD opcode)
  6262. {
  6263.     ULONG srcreg = 6;
  6264.     ULONG dstreg = (opcode & 7) >> 0;
  6265. {{    ULONG src = srcreg;
  6266. {    LONG dst = regs.a[dstreg];
  6267. {    ULONG newv = dst + src;
  6268.     regs.a[dstreg] = (newv);
  6269. }}}}}
  6270. void op_5c50(UWORD opcode)
  6271. {
  6272.     ULONG srcreg = 6;
  6273.     ULONG dstreg = (opcode & 7) >> 0;
  6274. {{    ULONG src = srcreg;
  6275. {    CPTR dsta = regs.a[dstreg];
  6276.     WORD dst = get_word(dsta);
  6277. {    ULONG newv = dst + src;
  6278. {    bool flgs = ((WORD)(src)) < 0;
  6279.     bool flgo = ((WORD)(dst)) < 0;
  6280.     bool flgn = ((WORD)(newv)) < 0;
  6281.     regs.z = ((WORD)(newv)) == 0;
  6282.     regs.v = (flgs == flgo) && (flgn != flgo);
  6283.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6284.     regs.n = flgn != 0;
  6285.     put_word(dsta,newv);
  6286. }}}}}}
  6287. void op_5c58(UWORD opcode)
  6288. {
  6289.     ULONG srcreg = 6;
  6290.     ULONG dstreg = (opcode & 7) >> 0;
  6291. {{    ULONG src = srcreg;
  6292. {    CPTR dsta = regs.a[dstreg];
  6293.     WORD dst = get_word(dsta);
  6294. {    regs.a[dstreg] += 2;
  6295. {    ULONG newv = dst + src;
  6296. {    bool flgs = ((WORD)(src)) < 0;
  6297.     bool flgo = ((WORD)(dst)) < 0;
  6298.     bool flgn = ((WORD)(newv)) < 0;
  6299.     regs.z = ((WORD)(newv)) == 0;
  6300.     regs.v = (flgs == flgo) && (flgn != flgo);
  6301.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6302.     regs.n = flgn != 0;
  6303.     put_word(dsta,newv);
  6304. }}}}}}}
  6305. void op_5c60(UWORD opcode)
  6306. {
  6307.     ULONG srcreg = 6;
  6308.     ULONG dstreg = (opcode & 7) >> 0;
  6309. {{    ULONG src = srcreg;
  6310. {    regs.a[dstreg] -= 2;
  6311. {    CPTR dsta = regs.a[dstreg];
  6312.     WORD dst = get_word(dsta);
  6313. {    ULONG newv = dst + src;
  6314. {    bool flgs = ((WORD)(src)) < 0;
  6315.     bool flgo = ((WORD)(dst)) < 0;
  6316.     bool flgn = ((WORD)(newv)) < 0;
  6317.     regs.z = ((WORD)(newv)) == 0;
  6318.     regs.v = (flgs == flgo) && (flgn != flgo);
  6319.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6320.     regs.n = flgn != 0;
  6321.     put_word(dsta,newv);
  6322. }}}}}}}
  6323. void op_5c68(UWORD opcode)
  6324. {
  6325.     ULONG srcreg = 6;
  6326.     ULONG dstreg = (opcode & 7) >> 0;
  6327. {{    ULONG src = srcreg;
  6328. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6329.     WORD dst = get_word(dsta);
  6330. {    ULONG newv = dst + src;
  6331. {    bool flgs = ((WORD)(src)) < 0;
  6332.     bool flgo = ((WORD)(dst)) < 0;
  6333.     bool flgn = ((WORD)(newv)) < 0;
  6334.     regs.z = ((WORD)(newv)) == 0;
  6335.     regs.v = (flgs == flgo) && (flgn != flgo);
  6336.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6337.     regs.n = flgn != 0;
  6338.     put_word(dsta,newv);
  6339. }}}}}}
  6340. void op_5c70(UWORD opcode)
  6341. {
  6342.     ULONG srcreg = 6;
  6343.     ULONG dstreg = (opcode & 7) >> 0;
  6344. {{    ULONG src = srcreg;
  6345. {    CPTR dsta = regs.a[dstreg];
  6346.     UWORD dstdp = nextiword();
  6347.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  6348. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  6349.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  6350.     dsta += dstdpr;
  6351. {    WORD dst = get_word(dsta);
  6352. {    ULONG newv = dst + src;
  6353. {    bool flgs = ((WORD)(src)) < 0;
  6354.     bool flgo = ((WORD)(dst)) < 0;
  6355.     bool flgn = ((WORD)(newv)) < 0;
  6356.     regs.z = ((WORD)(newv)) == 0;
  6357.     regs.v = (flgs == flgo) && (flgn != flgo);
  6358.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6359.     regs.n = flgn != 0;
  6360.     put_word(dsta,newv);
  6361. }}}}}}}}
  6362. void op_5c78(UWORD opcode)
  6363. {
  6364.     ULONG srcreg = 6;
  6365. {{    ULONG src = srcreg;
  6366. {    CPTR dsta = (LONG)(WORD)nextiword();
  6367.     WORD dst = get_word(dsta);
  6368. {    ULONG newv = dst + src;
  6369. {    bool flgs = ((WORD)(src)) < 0;
  6370.     bool flgo = ((WORD)(dst)) < 0;
  6371.     bool flgn = ((WORD)(newv)) < 0;
  6372.     regs.z = ((WORD)(newv)) == 0;
  6373.     regs.v = (flgs == flgo) && (flgn != flgo);
  6374.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6375.     regs.n = flgn != 0;
  6376.     put_word(dsta,newv);
  6377. }}}}}}
  6378. void op_5c79(UWORD opcode)
  6379. {
  6380.     ULONG srcreg = 6;
  6381. {{    ULONG src = srcreg;
  6382. {    CPTR dsta = nextilong();
  6383.     WORD dst = get_word(dsta);
  6384. {    ULONG newv = dst + src;
  6385. {    bool flgs = ((WORD)(src)) < 0;
  6386.     bool flgo = ((WORD)(dst)) < 0;
  6387.     bool flgn = ((WORD)(newv)) < 0;
  6388.     regs.z = ((WORD)(newv)) == 0;
  6389.     regs.v = (flgs == flgo) && (flgn != flgo);
  6390.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  6391.     regs.n = flgn != 0;
  6392.     put_word(dsta,newv);
  6393. }}}}}}
  6394. void op_5c80(UWORD opcode)
  6395. {
  6396.     ULONG srcreg = 6;
  6397.     ULONG dstreg = (opcode & 7) >> 0;
  6398. {{    ULONG src = srcreg;
  6399. {    LONG dst = regs.d[dstreg];
  6400. {    ULONG newv = dst + src;
  6401. {    bool flgs = ((LONG)(src)) < 0;
  6402.     bool flgo = ((LONG)(dst)) < 0;
  6403.     bool flgn = ((LONG)(newv)) < 0;
  6404.     regs.z = ((LONG)(newv)) == 0;
  6405.     regs.v = (flgs == flgo) && (flgn != flgo);
  6406.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6407.     regs.n = flgn != 0;
  6408.     regs.d[dstreg] = (newv);
  6409. }}}}}}
  6410. void op_5c88(UWORD opcode)
  6411. {
  6412.     ULONG srcreg = 6;
  6413.     ULONG dstreg = (opcode & 7) >> 0;
  6414. {{    ULONG src = srcreg;
  6415. {    LONG dst = regs.a[dstreg];
  6416. {    ULONG newv = dst + src;
  6417.     regs.a[dstreg] = (newv);
  6418. }}}}}
  6419. void op_5c90(UWORD opcode)
  6420. {
  6421.     ULONG srcreg = 6;
  6422.     ULONG dstreg = (opcode & 7) >> 0;
  6423. {{    ULONG src = srcreg;
  6424. {    CPTR dsta = regs.a[dstreg];
  6425.     LONG dst = get_long(dsta);
  6426. {    ULONG newv = dst + src;
  6427. {    bool flgs = ((LONG)(src)) < 0;
  6428.     bool flgo = ((LONG)(dst)) < 0;
  6429.     bool flgn = ((LONG)(newv)) < 0;
  6430.     regs.z = ((LONG)(newv)) == 0;
  6431.     regs.v = (flgs == flgo) && (flgn != flgo);
  6432.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6433.     regs.n = flgn != 0;
  6434.     put_long(dsta,newv);
  6435. }}}}}}
  6436. void op_5c98(UWORD opcode)
  6437. {
  6438.     ULONG srcreg = 6;
  6439.     ULONG dstreg = (opcode & 7) >> 0;
  6440. {{    ULONG src = srcreg;
  6441. {    CPTR dsta = regs.a[dstreg];
  6442.     LONG dst = get_long(dsta);
  6443. {    regs.a[dstreg] += 4;
  6444. {    ULONG newv = dst + src;
  6445. {    bool flgs = ((LONG)(src)) < 0;
  6446.     bool flgo = ((LONG)(dst)) < 0;
  6447.     bool flgn = ((LONG)(newv)) < 0;
  6448.     regs.z = ((LONG)(newv)) == 0;
  6449.     regs.v = (flgs == flgo) && (flgn != flgo);
  6450.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6451.     regs.n = flgn != 0;
  6452.     put_long(dsta,newv);
  6453. }}}}}}}
  6454. void op_5ca0(UWORD opcode)
  6455. {
  6456.     ULONG srcreg = 6;
  6457.     ULONG dstreg = (opcode & 7) >> 0;
  6458. {{    ULONG src = srcreg;
  6459. {    regs.a[dstreg] -= 4;
  6460. {    CPTR dsta = regs.a[dstreg];
  6461.     LONG dst = get_long(dsta);
  6462. {    ULONG newv = dst + src;
  6463. {    bool flgs = ((LONG)(src)) < 0;
  6464.     bool flgo = ((LONG)(dst)) < 0;
  6465.     bool flgn = ((LONG)(newv)) < 0;
  6466.     regs.z = ((LONG)(newv)) == 0;
  6467.     regs.v = (flgs == flgo) && (flgn != flgo);
  6468.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6469.     regs.n = flgn != 0;
  6470.     put_long(dsta,newv);
  6471. }}}}}}}
  6472. void op_5ca8(UWORD opcode)
  6473. {
  6474.     ULONG srcreg = 6;
  6475.     ULONG dstreg = (opcode & 7) >> 0;
  6476. {{    ULONG src = srcreg;
  6477. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6478.     LONG dst = get_long(dsta);
  6479. {    ULONG newv = dst + src;
  6480. {    bool flgs = ((LONG)(src)) < 0;
  6481.     bool flgo = ((LONG)(dst)) < 0;
  6482.     bool flgn = ((LONG)(newv)) < 0;
  6483.     regs.z = ((LONG)(newv)) == 0;
  6484.     regs.v = (flgs == flgo) && (flgn != flgo);
  6485.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6486.     regs.n = flgn != 0;
  6487.     put_long(dsta,newv);
  6488. }}}}}}
  6489. void op_5cb0(UWORD opcode)
  6490. {
  6491.     ULONG srcreg = 6;
  6492.     ULONG dstreg = (opcode & 7) >> 0;
  6493. {{    ULONG src = srcreg;
  6494. {    CPTR dsta = regs.a[dstreg];
  6495.     UWORD dstdp = nextiword();
  6496.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  6497. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  6498.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  6499.     dsta += dstdpr;
  6500. {    LONG dst = get_long(dsta);
  6501. {    ULONG newv = dst + src;
  6502. {    bool flgs = ((LONG)(src)) < 0;
  6503.     bool flgo = ((LONG)(dst)) < 0;
  6504.     bool flgn = ((LONG)(newv)) < 0;
  6505.     regs.z = ((LONG)(newv)) == 0;
  6506.     regs.v = (flgs == flgo) && (flgn != flgo);
  6507.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6508.     regs.n = flgn != 0;
  6509.     put_long(dsta,newv);
  6510. }}}}}}}}
  6511. void op_5cb8(UWORD opcode)
  6512. {
  6513.     ULONG srcreg = 6;
  6514. {{    ULONG src = srcreg;
  6515. {    CPTR dsta = (LONG)(WORD)nextiword();
  6516.     LONG dst = get_long(dsta);
  6517. {    ULONG newv = dst + src;
  6518. {    bool flgs = ((LONG)(src)) < 0;
  6519.     bool flgo = ((LONG)(dst)) < 0;
  6520.     bool flgn = ((LONG)(newv)) < 0;
  6521.     regs.z = ((LONG)(newv)) == 0;
  6522.     regs.v = (flgs == flgo) && (flgn != flgo);
  6523.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6524.     regs.n = flgn != 0;
  6525.     put_long(dsta,newv);
  6526. }}}}}}
  6527. void op_5cb9(UWORD opcode)
  6528. {
  6529.     ULONG srcreg = 6;
  6530. {{    ULONG src = srcreg;
  6531. {    CPTR dsta = nextilong();
  6532.     LONG dst = get_long(dsta);
  6533. {    ULONG newv = dst + src;
  6534. {    bool flgs = ((LONG)(src)) < 0;
  6535.     bool flgo = ((LONG)(dst)) < 0;
  6536.     bool flgn = ((LONG)(newv)) < 0;
  6537.     regs.z = ((LONG)(newv)) == 0;
  6538.     regs.v = (flgs == flgo) && (flgn != flgo);
  6539.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  6540.     regs.n = flgn != 0;
  6541.     put_long(dsta,newv);
  6542. }}}}}}
  6543. void op_5cc0(UWORD opcode)
  6544. {
  6545.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6546. {{{    int val = cctrue(12) ? 0xff : 0;
  6547.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  6548. }}}}
  6549. void op_5cc8(UWORD opcode)
  6550. {
  6551.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6552. {{    WORD src = regs.d[srcreg];
  6553. {    WORD offs = nextiword();
  6554.     if (!cctrue(12)) {
  6555.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  6556.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  6557.     }
  6558. }}}}
  6559. void op_5cd0(UWORD opcode)
  6560. {
  6561.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6562. {{    CPTR srca = regs.a[srcreg];
  6563. {    int val = cctrue(12) ? 0xff : 0;
  6564.     put_byte(srca,val);
  6565. }}}}
  6566. void op_5cd8(UWORD opcode)
  6567. {
  6568.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6569. {{    CPTR srca = regs.a[srcreg];
  6570. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  6571. {    int val = cctrue(12) ? 0xff : 0;
  6572.     put_byte(srca,val);
  6573. }}}}}
  6574. void op_5ce0(UWORD opcode)
  6575. {
  6576.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6577. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  6578. {    CPTR srca = regs.a[srcreg];
  6579. {    int val = cctrue(12) ? 0xff : 0;
  6580.     put_byte(srca,val);
  6581. }}}}}
  6582. void op_5ce8(UWORD opcode)
  6583. {
  6584.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6585. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  6586. {    int val = cctrue(12) ? 0xff : 0;
  6587.     put_byte(srca,val);
  6588. }}}}
  6589. void op_5cf0(UWORD opcode)
  6590. {
  6591.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  6592. {{    CPTR srca = regs.a[srcreg];
  6593.     UWORD srcdp = nextiword();
  6594.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  6595. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  6596.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  6597.     srca += srcdpr;
  6598. {    int val = cctrue(12) ? 0xff : 0;
  6599.     put_byte(srca,val);
  6600. }}}}}
  6601. void op_5cf8(UWORD opcode)
  6602. {
  6603. {{    CPTR srca = (LONG)(WORD)nextiword();
  6604. {    int val = cctrue(12) ? 0xff : 0;
  6605.     put_byte(srca,val);
  6606. }}}}
  6607. void op_5cf9(UWORD opcode)
  6608. {
  6609. {{    CPTR srca = nextilong();
  6610. {    int val = cctrue(12) ? 0xff : 0;
  6611.     put_byte(srca,val);
  6612. }}}}
  6613. void op_5d00(UWORD opcode)
  6614. {
  6615.     ULONG srcreg = 6;
  6616.     ULONG dstreg = (opcode & 7) >> 0;
  6617. {{    ULONG src = srcreg;
  6618. {    BYTE dst = regs.d[dstreg];
  6619. {    ULONG newv = dst - src;
  6620. {    bool flgs = ((BYTE)(src)) < 0;
  6621.     bool flgo = ((BYTE)(dst)) < 0;
  6622.     bool flgn = ((BYTE)(newv)) < 0;
  6623.     regs.z = ((BYTE)(newv)) == 0;
  6624.     regs.v = (flgs != flgo) && (flgn != flgo);
  6625.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6626.     regs.n = flgn != 0;
  6627.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  6628. }}}}}}
  6629. void op_5d10(UWORD opcode)
  6630. {
  6631.     ULONG srcreg = 6;
  6632.     ULONG dstreg = (opcode & 7) >> 0;
  6633. {{    ULONG src = srcreg;
  6634. {    CPTR dsta = regs.a[dstreg];
  6635.     BYTE dst = get_byte(dsta);
  6636. {    ULONG newv = dst - src;
  6637. {    bool flgs = ((BYTE)(src)) < 0;
  6638.     bool flgo = ((BYTE)(dst)) < 0;
  6639.     bool flgn = ((BYTE)(newv)) < 0;
  6640.     regs.z = ((BYTE)(newv)) == 0;
  6641.     regs.v = (flgs != flgo) && (flgn != flgo);
  6642.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6643.     regs.n = flgn != 0;
  6644.     put_byte(dsta,newv);
  6645. }}}}}}
  6646. void op_5d18(UWORD opcode)
  6647. {
  6648.     ULONG srcreg = 6;
  6649.     ULONG dstreg = (opcode & 7) >> 0;
  6650. {{    ULONG src = srcreg;
  6651. {    CPTR dsta = regs.a[dstreg];
  6652.     BYTE dst = get_byte(dsta);
  6653. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  6654. {    ULONG newv = dst - src;
  6655. {    bool flgs = ((BYTE)(src)) < 0;
  6656.     bool flgo = ((BYTE)(dst)) < 0;
  6657.     bool flgn = ((BYTE)(newv)) < 0;
  6658.     regs.z = ((BYTE)(newv)) == 0;
  6659.     regs.v = (flgs != flgo) && (flgn != flgo);
  6660.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6661.     regs.n = flgn != 0;
  6662.     put_byte(dsta,newv);
  6663. }}}}}}}
  6664. void op_5d20(UWORD opcode)
  6665. {
  6666.     ULONG srcreg = 6;
  6667.     ULONG dstreg = (opcode & 7) >> 0;
  6668. {{    ULONG src = srcreg;
  6669. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  6670. {    CPTR dsta = regs.a[dstreg];
  6671.     BYTE dst = get_byte(dsta);
  6672. {    ULONG newv = dst - src;
  6673. {    bool flgs = ((BYTE)(src)) < 0;
  6674.     bool flgo = ((BYTE)(dst)) < 0;
  6675.     bool flgn = ((BYTE)(newv)) < 0;
  6676.     regs.z = ((BYTE)(newv)) == 0;
  6677.     regs.v = (flgs != flgo) && (flgn != flgo);
  6678.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6679.     regs.n = flgn != 0;
  6680.     put_byte(dsta,newv);
  6681. }}}}}}}
  6682. void op_5d28(UWORD opcode)
  6683. {
  6684.     ULONG srcreg = 6;
  6685.     ULONG dstreg = (opcode & 7) >> 0;
  6686. {{    ULONG src = srcreg;
  6687. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6688.     BYTE dst = get_byte(dsta);
  6689. {    ULONG newv = dst - src;
  6690. {    bool flgs = ((BYTE)(src)) < 0;
  6691.     bool flgo = ((BYTE)(dst)) < 0;
  6692.     bool flgn = ((BYTE)(newv)) < 0;
  6693.     regs.z = ((BYTE)(newv)) == 0;
  6694.     regs.v = (flgs != flgo) && (flgn != flgo);
  6695.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6696.     regs.n = flgn != 0;
  6697.     put_byte(dsta,newv);
  6698. }}}}}}
  6699. void op_5d30(UWORD opcode)
  6700. {
  6701.     ULONG srcreg = 6;
  6702.     ULONG dstreg = (opcode & 7) >> 0;
  6703. {{    ULONG src = srcreg;
  6704. {    CPTR dsta = regs.a[dstreg];
  6705.     UWORD dstdp = nextiword();
  6706.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  6707. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  6708.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  6709.     dsta += dstdpr;
  6710. {    BYTE dst = get_byte(dsta);
  6711. {    ULONG newv = dst - src;
  6712. {    bool flgs = ((BYTE)(src)) < 0;
  6713.     bool flgo = ((BYTE)(dst)) < 0;
  6714.     bool flgn = ((BYTE)(newv)) < 0;
  6715.     regs.z = ((BYTE)(newv)) == 0;
  6716.     regs.v = (flgs != flgo) && (flgn != flgo);
  6717.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6718.     regs.n = flgn != 0;
  6719.     put_byte(dsta,newv);
  6720. }}}}}}}}
  6721. void op_5d38(UWORD opcode)
  6722. {
  6723.     ULONG srcreg = 6;
  6724. {{    ULONG src = srcreg;
  6725. {    CPTR dsta = (LONG)(WORD)nextiword();
  6726.     BYTE dst = get_byte(dsta);
  6727. {    ULONG newv = dst - src;
  6728. {    bool flgs = ((BYTE)(src)) < 0;
  6729.     bool flgo = ((BYTE)(dst)) < 0;
  6730.     bool flgn = ((BYTE)(newv)) < 0;
  6731.     regs.z = ((BYTE)(newv)) == 0;
  6732.     regs.v = (flgs != flgo) && (flgn != flgo);
  6733.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6734.     regs.n = flgn != 0;
  6735.     put_byte(dsta,newv);
  6736. }}}}}}
  6737. void op_5d39(UWORD opcode)
  6738. {
  6739.     ULONG srcreg = 6;
  6740. {{    ULONG src = srcreg;
  6741. {    CPTR dsta = nextilong();
  6742.     BYTE dst = get_byte(dsta);
  6743. {    ULONG newv = dst - src;
  6744. {    bool flgs = ((BYTE)(src)) < 0;
  6745.     bool flgo = ((BYTE)(dst)) < 0;
  6746.     bool flgn = ((BYTE)(newv)) < 0;
  6747.     regs.z = ((BYTE)(newv)) == 0;
  6748.     regs.v = (flgs != flgo) && (flgn != flgo);
  6749.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  6750.     regs.n = flgn != 0;
  6751.     put_byte(dsta,newv);
  6752. }}}}}}
  6753. void op_5d40(UWORD opcode)
  6754. {
  6755.     ULONG srcreg = 6;
  6756.     ULONG dstreg = (opcode & 7) >> 0;
  6757. {{    ULONG src = srcreg;
  6758. {    WORD dst = regs.d[dstreg];
  6759. {    ULONG newv = dst - src;
  6760. {    bool flgs = ((WORD)(src)) < 0;
  6761.     bool flgo = ((WORD)(dst)) < 0;
  6762.     bool flgn = ((WORD)(newv)) < 0;
  6763.     regs.z = ((WORD)(newv)) == 0;
  6764.     regs.v = (flgs != flgo) && (flgn != flgo);
  6765.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6766.     regs.n = flgn != 0;
  6767.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  6768. }}}}}}
  6769. void op_5d48(UWORD opcode)
  6770. {
  6771.     ULONG srcreg = 6;
  6772.     ULONG dstreg = (opcode & 7) >> 0;
  6773. {{    ULONG src = srcreg;
  6774. {    LONG dst = regs.a[dstreg];
  6775. {    ULONG newv = dst - src;
  6776.     regs.a[dstreg] = (newv);
  6777. }}}}}
  6778. void op_5d50(UWORD opcode)
  6779. {
  6780.     ULONG srcreg = 6;
  6781.     ULONG dstreg = (opcode & 7) >> 0;
  6782. {{    ULONG src = srcreg;
  6783. {    CPTR dsta = regs.a[dstreg];
  6784.     WORD dst = get_word(dsta);
  6785. {    ULONG newv = dst - src;
  6786. {    bool flgs = ((WORD)(src)) < 0;
  6787.     bool flgo = ((WORD)(dst)) < 0;
  6788.     bool flgn = ((WORD)(newv)) < 0;
  6789.     regs.z = ((WORD)(newv)) == 0;
  6790.     regs.v = (flgs != flgo) && (flgn != flgo);
  6791.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6792.     regs.n = flgn != 0;
  6793.     put_word(dsta,newv);
  6794. }}}}}}
  6795. void op_5d58(UWORD opcode)
  6796. {
  6797.     ULONG srcreg = 6;
  6798.     ULONG dstreg = (opcode & 7) >> 0;
  6799. {{    ULONG src = srcreg;
  6800. {    CPTR dsta = regs.a[dstreg];
  6801.     WORD dst = get_word(dsta);
  6802. {    regs.a[dstreg] += 2;
  6803. {    ULONG newv = dst - src;
  6804. {    bool flgs = ((WORD)(src)) < 0;
  6805.     bool flgo = ((WORD)(dst)) < 0;
  6806.     bool flgn = ((WORD)(newv)) < 0;
  6807.     regs.z = ((WORD)(newv)) == 0;
  6808.     regs.v = (flgs != flgo) && (flgn != flgo);
  6809.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6810.     regs.n = flgn != 0;
  6811.     put_word(dsta,newv);
  6812. }}}}}}}
  6813. void op_5d60(UWORD opcode)
  6814. {
  6815.     ULONG srcreg = 6;
  6816.     ULONG dstreg = (opcode & 7) >> 0;
  6817. {{    ULONG src = srcreg;
  6818. {    regs.a[dstreg] -= 2;
  6819. {    CPTR dsta = regs.a[dstreg];
  6820.     WORD dst = get_word(dsta);
  6821. {    ULONG newv = dst - src;
  6822. {    bool flgs = ((WORD)(src)) < 0;
  6823.     bool flgo = ((WORD)(dst)) < 0;
  6824.     bool flgn = ((WORD)(newv)) < 0;
  6825.     regs.z = ((WORD)(newv)) == 0;
  6826.     regs.v = (flgs != flgo) && (flgn != flgo);
  6827.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6828.     regs.n = flgn != 0;
  6829.     put_word(dsta,newv);
  6830. }}}}}}}
  6831. void op_5d68(UWORD opcode)
  6832. {
  6833.     ULONG srcreg = 6;
  6834.     ULONG dstreg = (opcode & 7) >> 0;
  6835. {{    ULONG src = srcreg;
  6836. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6837.     WORD dst = get_word(dsta);
  6838. {    ULONG newv = dst - src;
  6839. {    bool flgs = ((WORD)(src)) < 0;
  6840.     bool flgo = ((WORD)(dst)) < 0;
  6841.     bool flgn = ((WORD)(newv)) < 0;
  6842.     regs.z = ((WORD)(newv)) == 0;
  6843.     regs.v = (flgs != flgo) && (flgn != flgo);
  6844.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6845.     regs.n = flgn != 0;
  6846.     put_word(dsta,newv);
  6847. }}}}}}
  6848. void op_5d70(UWORD opcode)
  6849. {
  6850.     ULONG srcreg = 6;
  6851.     ULONG dstreg = (opcode & 7) >> 0;
  6852. {{    ULONG src = srcreg;
  6853. {    CPTR dsta = regs.a[dstreg];
  6854.     UWORD dstdp = nextiword();
  6855.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  6856. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  6857.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  6858.     dsta += dstdpr;
  6859. {    WORD dst = get_word(dsta);
  6860. {    ULONG newv = dst - src;
  6861. {    bool flgs = ((WORD)(src)) < 0;
  6862.     bool flgo = ((WORD)(dst)) < 0;
  6863.     bool flgn = ((WORD)(newv)) < 0;
  6864.     regs.z = ((WORD)(newv)) == 0;
  6865.     regs.v = (flgs != flgo) && (flgn != flgo);
  6866.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6867.     regs.n = flgn != 0;
  6868.     put_word(dsta,newv);
  6869. }}}}}}}}
  6870. void op_5d78(UWORD opcode)
  6871. {
  6872.     ULONG srcreg = 6;
  6873. {{    ULONG src = srcreg;
  6874. {    CPTR dsta = (LONG)(WORD)nextiword();
  6875.     WORD dst = get_word(dsta);
  6876. {    ULONG newv = dst - src;
  6877. {    bool flgs = ((WORD)(src)) < 0;
  6878.     bool flgo = ((WORD)(dst)) < 0;
  6879.     bool flgn = ((WORD)(newv)) < 0;
  6880.     regs.z = ((WORD)(newv)) == 0;
  6881.     regs.v = (flgs != flgo) && (flgn != flgo);
  6882.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6883.     regs.n = flgn != 0;
  6884.     put_word(dsta,newv);
  6885. }}}}}}
  6886. void op_5d79(UWORD opcode)
  6887. {
  6888.     ULONG srcreg = 6;
  6889. {{    ULONG src = srcreg;
  6890. {    CPTR dsta = nextilong();
  6891.     WORD dst = get_word(dsta);
  6892. {    ULONG newv = dst - src;
  6893. {    bool flgs = ((WORD)(src)) < 0;
  6894.     bool flgo = ((WORD)(dst)) < 0;
  6895.     bool flgn = ((WORD)(newv)) < 0;
  6896.     regs.z = ((WORD)(newv)) == 0;
  6897.     regs.v = (flgs != flgo) && (flgn != flgo);
  6898.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  6899.     regs.n = flgn != 0;
  6900.     put_word(dsta,newv);
  6901. }}}}}}
  6902. void op_5d80(UWORD opcode)
  6903. {
  6904.     ULONG srcreg = 6;
  6905.     ULONG dstreg = (opcode & 7) >> 0;
  6906. {{    ULONG src = srcreg;
  6907. {    LONG dst = regs.d[dstreg];
  6908. {    ULONG newv = dst - src;
  6909. {    bool flgs = ((LONG)(src)) < 0;
  6910.     bool flgo = ((LONG)(dst)) < 0;
  6911.     bool flgn = ((LONG)(newv)) < 0;
  6912.     regs.z = ((LONG)(newv)) == 0;
  6913.     regs.v = (flgs != flgo) && (flgn != flgo);
  6914.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6915.     regs.n = flgn != 0;
  6916.     regs.d[dstreg] = (newv);
  6917. }}}}}}
  6918. void op_5d88(UWORD opcode)
  6919. {
  6920.     ULONG srcreg = 6;
  6921.     ULONG dstreg = (opcode & 7) >> 0;
  6922. {{    ULONG src = srcreg;
  6923. {    LONG dst = regs.a[dstreg];
  6924. {    ULONG newv = dst - src;
  6925.     regs.a[dstreg] = (newv);
  6926. }}}}}
  6927. void op_5d90(UWORD opcode)
  6928. {
  6929.     ULONG srcreg = 6;
  6930.     ULONG dstreg = (opcode & 7) >> 0;
  6931. {{    ULONG src = srcreg;
  6932. {    CPTR dsta = regs.a[dstreg];
  6933.     LONG dst = get_long(dsta);
  6934. {    ULONG newv = dst - src;
  6935. {    bool flgs = ((LONG)(src)) < 0;
  6936.     bool flgo = ((LONG)(dst)) < 0;
  6937.     bool flgn = ((LONG)(newv)) < 0;
  6938.     regs.z = ((LONG)(newv)) == 0;
  6939.     regs.v = (flgs != flgo) && (flgn != flgo);
  6940.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6941.     regs.n = flgn != 0;
  6942.     put_long(dsta,newv);
  6943. }}}}}}
  6944. void op_5d98(UWORD opcode)
  6945. {
  6946.     ULONG srcreg = 6;
  6947.     ULONG dstreg = (opcode & 7) >> 0;
  6948. {{    ULONG src = srcreg;
  6949. {    CPTR dsta = regs.a[dstreg];
  6950.     LONG dst = get_long(dsta);
  6951. {    regs.a[dstreg] += 4;
  6952. {    ULONG newv = dst - src;
  6953. {    bool flgs = ((LONG)(src)) < 0;
  6954.     bool flgo = ((LONG)(dst)) < 0;
  6955.     bool flgn = ((LONG)(newv)) < 0;
  6956.     regs.z = ((LONG)(newv)) == 0;
  6957.     regs.v = (flgs != flgo) && (flgn != flgo);
  6958.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6959.     regs.n = flgn != 0;
  6960.     put_long(dsta,newv);
  6961. }}}}}}}
  6962. void op_5da0(UWORD opcode)
  6963. {
  6964.     ULONG srcreg = 6;
  6965.     ULONG dstreg = (opcode & 7) >> 0;
  6966. {{    ULONG src = srcreg;
  6967. {    regs.a[dstreg] -= 4;
  6968. {    CPTR dsta = regs.a[dstreg];
  6969.     LONG dst = get_long(dsta);
  6970. {    ULONG newv = dst - src;
  6971. {    bool flgs = ((LONG)(src)) < 0;
  6972.     bool flgo = ((LONG)(dst)) < 0;
  6973.     bool flgn = ((LONG)(newv)) < 0;
  6974.     regs.z = ((LONG)(newv)) == 0;
  6975.     regs.v = (flgs != flgo) && (flgn != flgo);
  6976.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6977.     regs.n = flgn != 0;
  6978.     put_long(dsta,newv);
  6979. }}}}}}}
  6980. void op_5da8(UWORD opcode)
  6981. {
  6982.     ULONG srcreg = 6;
  6983.     ULONG dstreg = (opcode & 7) >> 0;
  6984. {{    ULONG src = srcreg;
  6985. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  6986.     LONG dst = get_long(dsta);
  6987. {    ULONG newv = dst - src;
  6988. {    bool flgs = ((LONG)(src)) < 0;
  6989.     bool flgo = ((LONG)(dst)) < 0;
  6990.     bool flgn = ((LONG)(newv)) < 0;
  6991.     regs.z = ((LONG)(newv)) == 0;
  6992.     regs.v = (flgs != flgo) && (flgn != flgo);
  6993.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  6994.     regs.n = flgn != 0;
  6995.     put_long(dsta,newv);
  6996. }}}}}}
  6997. void op_5db0(UWORD opcode)
  6998. {
  6999.     ULONG srcreg = 6;
  7000.     ULONG dstreg = (opcode & 7) >> 0;
  7001. {{    ULONG src = srcreg;
  7002. {    CPTR dsta = regs.a[dstreg];
  7003.     UWORD dstdp = nextiword();
  7004.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7005. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7006.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7007.     dsta += dstdpr;
  7008. {    LONG dst = get_long(dsta);
  7009. {    ULONG newv = dst - src;
  7010. {    bool flgs = ((LONG)(src)) < 0;
  7011.     bool flgo = ((LONG)(dst)) < 0;
  7012.     bool flgn = ((LONG)(newv)) < 0;
  7013.     regs.z = ((LONG)(newv)) == 0;
  7014.     regs.v = (flgs != flgo) && (flgn != flgo);
  7015.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7016.     regs.n = flgn != 0;
  7017.     put_long(dsta,newv);
  7018. }}}}}}}}
  7019. void op_5db8(UWORD opcode)
  7020. {
  7021.     ULONG srcreg = 6;
  7022. {{    ULONG src = srcreg;
  7023. {    CPTR dsta = (LONG)(WORD)nextiword();
  7024.     LONG dst = get_long(dsta);
  7025. {    ULONG newv = dst - src;
  7026. {    bool flgs = ((LONG)(src)) < 0;
  7027.     bool flgo = ((LONG)(dst)) < 0;
  7028.     bool flgn = ((LONG)(newv)) < 0;
  7029.     regs.z = ((LONG)(newv)) == 0;
  7030.     regs.v = (flgs != flgo) && (flgn != flgo);
  7031.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7032.     regs.n = flgn != 0;
  7033.     put_long(dsta,newv);
  7034. }}}}}}
  7035. void op_5db9(UWORD opcode)
  7036. {
  7037.     ULONG srcreg = 6;
  7038. {{    ULONG src = srcreg;
  7039. {    CPTR dsta = nextilong();
  7040.     LONG dst = get_long(dsta);
  7041. {    ULONG newv = dst - src;
  7042. {    bool flgs = ((LONG)(src)) < 0;
  7043.     bool flgo = ((LONG)(dst)) < 0;
  7044.     bool flgn = ((LONG)(newv)) < 0;
  7045.     regs.z = ((LONG)(newv)) == 0;
  7046.     regs.v = (flgs != flgo) && (flgn != flgo);
  7047.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7048.     regs.n = flgn != 0;
  7049.     put_long(dsta,newv);
  7050. }}}}}}
  7051. void op_5dc0(UWORD opcode)
  7052. {
  7053.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7054. {{{    int val = cctrue(13) ? 0xff : 0;
  7055.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  7056. }}}}
  7057. void op_5dc8(UWORD opcode)
  7058. {
  7059.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7060. {{    WORD src = regs.d[srcreg];
  7061. {    WORD offs = nextiword();
  7062.     if (!cctrue(13)) {
  7063.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  7064.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  7065.     }
  7066. }}}}
  7067. void op_5dd0(UWORD opcode)
  7068. {
  7069.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7070. {{    CPTR srca = regs.a[srcreg];
  7071. {    int val = cctrue(13) ? 0xff : 0;
  7072.     put_byte(srca,val);
  7073. }}}}
  7074. void op_5dd8(UWORD opcode)
  7075. {
  7076.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7077. {{    CPTR srca = regs.a[srcreg];
  7078. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  7079. {    int val = cctrue(13) ? 0xff : 0;
  7080.     put_byte(srca,val);
  7081. }}}}}
  7082. void op_5de0(UWORD opcode)
  7083. {
  7084.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7085. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  7086. {    CPTR srca = regs.a[srcreg];
  7087. {    int val = cctrue(13) ? 0xff : 0;
  7088.     put_byte(srca,val);
  7089. }}}}}
  7090. void op_5de8(UWORD opcode)
  7091. {
  7092.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7093. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  7094. {    int val = cctrue(13) ? 0xff : 0;
  7095.     put_byte(srca,val);
  7096. }}}}
  7097. void op_5df0(UWORD opcode)
  7098. {
  7099.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7100. {{    CPTR srca = regs.a[srcreg];
  7101.     UWORD srcdp = nextiword();
  7102.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  7103. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  7104.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  7105.     srca += srcdpr;
  7106. {    int val = cctrue(13) ? 0xff : 0;
  7107.     put_byte(srca,val);
  7108. }}}}}
  7109. void op_5df8(UWORD opcode)
  7110. {
  7111. {{    CPTR srca = (LONG)(WORD)nextiword();
  7112. {    int val = cctrue(13) ? 0xff : 0;
  7113.     put_byte(srca,val);
  7114. }}}}
  7115. void op_5df9(UWORD opcode)
  7116. {
  7117. {{    CPTR srca = nextilong();
  7118. {    int val = cctrue(13) ? 0xff : 0;
  7119.     put_byte(srca,val);
  7120. }}}}
  7121. void op_5e00(UWORD opcode)
  7122. {
  7123.     ULONG srcreg = 7;
  7124.     ULONG dstreg = (opcode & 7) >> 0;
  7125. {{    ULONG src = srcreg;
  7126. {    BYTE dst = regs.d[dstreg];
  7127. {    ULONG newv = dst + src;
  7128. {    bool flgs = ((BYTE)(src)) < 0;
  7129.     bool flgo = ((BYTE)(dst)) < 0;
  7130.     bool flgn = ((BYTE)(newv)) < 0;
  7131.     regs.z = ((BYTE)(newv)) == 0;
  7132.     regs.v = (flgs == flgo) && (flgn != flgo);
  7133.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7134.     regs.n = flgn != 0;
  7135.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  7136. }}}}}}
  7137. void op_5e10(UWORD opcode)
  7138. {
  7139.     ULONG srcreg = 7;
  7140.     ULONG dstreg = (opcode & 7) >> 0;
  7141. {{    ULONG src = srcreg;
  7142. {    CPTR dsta = regs.a[dstreg];
  7143.     BYTE dst = get_byte(dsta);
  7144. {    ULONG newv = dst + src;
  7145. {    bool flgs = ((BYTE)(src)) < 0;
  7146.     bool flgo = ((BYTE)(dst)) < 0;
  7147.     bool flgn = ((BYTE)(newv)) < 0;
  7148.     regs.z = ((BYTE)(newv)) == 0;
  7149.     regs.v = (flgs == flgo) && (flgn != flgo);
  7150.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7151.     regs.n = flgn != 0;
  7152.     put_byte(dsta,newv);
  7153. }}}}}}
  7154. void op_5e18(UWORD opcode)
  7155. {
  7156.     ULONG srcreg = 7;
  7157.     ULONG dstreg = (opcode & 7) >> 0;
  7158. {{    ULONG src = srcreg;
  7159. {    CPTR dsta = regs.a[dstreg];
  7160.     BYTE dst = get_byte(dsta);
  7161. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  7162. {    ULONG newv = dst + src;
  7163. {    bool flgs = ((BYTE)(src)) < 0;
  7164.     bool flgo = ((BYTE)(dst)) < 0;
  7165.     bool flgn = ((BYTE)(newv)) < 0;
  7166.     regs.z = ((BYTE)(newv)) == 0;
  7167.     regs.v = (flgs == flgo) && (flgn != flgo);
  7168.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7169.     regs.n = flgn != 0;
  7170.     put_byte(dsta,newv);
  7171. }}}}}}}
  7172. void op_5e20(UWORD opcode)
  7173. {
  7174.     ULONG srcreg = 7;
  7175.     ULONG dstreg = (opcode & 7) >> 0;
  7176. {{    ULONG src = srcreg;
  7177. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  7178. {    CPTR dsta = regs.a[dstreg];
  7179.     BYTE dst = get_byte(dsta);
  7180. {    ULONG newv = dst + src;
  7181. {    bool flgs = ((BYTE)(src)) < 0;
  7182.     bool flgo = ((BYTE)(dst)) < 0;
  7183.     bool flgn = ((BYTE)(newv)) < 0;
  7184.     regs.z = ((BYTE)(newv)) == 0;
  7185.     regs.v = (flgs == flgo) && (flgn != flgo);
  7186.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7187.     regs.n = flgn != 0;
  7188.     put_byte(dsta,newv);
  7189. }}}}}}}
  7190. void op_5e28(UWORD opcode)
  7191. {
  7192.     ULONG srcreg = 7;
  7193.     ULONG dstreg = (opcode & 7) >> 0;
  7194. {{    ULONG src = srcreg;
  7195. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  7196.     BYTE dst = get_byte(dsta);
  7197. {    ULONG newv = dst + src;
  7198. {    bool flgs = ((BYTE)(src)) < 0;
  7199.     bool flgo = ((BYTE)(dst)) < 0;
  7200.     bool flgn = ((BYTE)(newv)) < 0;
  7201.     regs.z = ((BYTE)(newv)) == 0;
  7202.     regs.v = (flgs == flgo) && (flgn != flgo);
  7203.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7204.     regs.n = flgn != 0;
  7205.     put_byte(dsta,newv);
  7206. }}}}}}
  7207. void op_5e30(UWORD opcode)
  7208. {
  7209.     ULONG srcreg = 7;
  7210.     ULONG dstreg = (opcode & 7) >> 0;
  7211. {{    ULONG src = srcreg;
  7212. {    CPTR dsta = regs.a[dstreg];
  7213.     UWORD dstdp = nextiword();
  7214.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7215. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7216.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7217.     dsta += dstdpr;
  7218. {    BYTE dst = get_byte(dsta);
  7219. {    ULONG newv = dst + src;
  7220. {    bool flgs = ((BYTE)(src)) < 0;
  7221.     bool flgo = ((BYTE)(dst)) < 0;
  7222.     bool flgn = ((BYTE)(newv)) < 0;
  7223.     regs.z = ((BYTE)(newv)) == 0;
  7224.     regs.v = (flgs == flgo) && (flgn != flgo);
  7225.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7226.     regs.n = flgn != 0;
  7227.     put_byte(dsta,newv);
  7228. }}}}}}}}
  7229. void op_5e38(UWORD opcode)
  7230. {
  7231.     ULONG srcreg = 7;
  7232. {{    ULONG src = srcreg;
  7233. {    CPTR dsta = (LONG)(WORD)nextiword();
  7234.     BYTE dst = get_byte(dsta);
  7235. {    ULONG newv = dst + src;
  7236. {    bool flgs = ((BYTE)(src)) < 0;
  7237.     bool flgo = ((BYTE)(dst)) < 0;
  7238.     bool flgn = ((BYTE)(newv)) < 0;
  7239.     regs.z = ((BYTE)(newv)) == 0;
  7240.     regs.v = (flgs == flgo) && (flgn != flgo);
  7241.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7242.     regs.n = flgn != 0;
  7243.     put_byte(dsta,newv);
  7244. }}}}}}
  7245. void op_5e39(UWORD opcode)
  7246. {
  7247.     ULONG srcreg = 7;
  7248. {{    ULONG src = srcreg;
  7249. {    CPTR dsta = nextilong();
  7250.     BYTE dst = get_byte(dsta);
  7251. {    ULONG newv = dst + src;
  7252. {    bool flgs = ((BYTE)(src)) < 0;
  7253.     bool flgo = ((BYTE)(dst)) < 0;
  7254.     bool flgn = ((BYTE)(newv)) < 0;
  7255.     regs.z = ((BYTE)(newv)) == 0;
  7256.     regs.v = (flgs == flgo) && (flgn != flgo);
  7257.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  7258.     regs.n = flgn != 0;
  7259.     put_byte(dsta,newv);
  7260. }}}}}}
  7261. void op_5e40(UWORD opcode)
  7262. {
  7263.     ULONG srcreg = 7;
  7264.     ULONG dstreg = (opcode & 7) >> 0;
  7265. {{    ULONG src = srcreg;
  7266. {    WORD dst = regs.d[dstreg];
  7267. {    ULONG newv = dst + src;
  7268. {    bool flgs = ((WORD)(src)) < 0;
  7269.     bool flgo = ((WORD)(dst)) < 0;
  7270.     bool flgn = ((WORD)(newv)) < 0;
  7271.     regs.z = ((WORD)(newv)) == 0;
  7272.     regs.v = (flgs == flgo) && (flgn != flgo);
  7273.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7274.     regs.n = flgn != 0;
  7275.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  7276. }}}}}}
  7277. void op_5e48(UWORD opcode)
  7278. {
  7279.     ULONG srcreg = 7;
  7280.     ULONG dstreg = (opcode & 7) >> 0;
  7281. {{    ULONG src = srcreg;
  7282. {    LONG dst = regs.a[dstreg];
  7283. {    ULONG newv = dst + src;
  7284.     regs.a[dstreg] = (newv);
  7285. }}}}}
  7286. void op_5e50(UWORD opcode)
  7287. {
  7288.     ULONG srcreg = 7;
  7289.     ULONG dstreg = (opcode & 7) >> 0;
  7290. {{    ULONG src = srcreg;
  7291. {    CPTR dsta = regs.a[dstreg];
  7292.     WORD dst = get_word(dsta);
  7293. {    ULONG newv = dst + src;
  7294. {    bool flgs = ((WORD)(src)) < 0;
  7295.     bool flgo = ((WORD)(dst)) < 0;
  7296.     bool flgn = ((WORD)(newv)) < 0;
  7297.     regs.z = ((WORD)(newv)) == 0;
  7298.     regs.v = (flgs == flgo) && (flgn != flgo);
  7299.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7300.     regs.n = flgn != 0;
  7301.     put_word(dsta,newv);
  7302. }}}}}}
  7303. void op_5e58(UWORD opcode)
  7304. {
  7305.     ULONG srcreg = 7;
  7306.     ULONG dstreg = (opcode & 7) >> 0;
  7307. {{    ULONG src = srcreg;
  7308. {    CPTR dsta = regs.a[dstreg];
  7309.     WORD dst = get_word(dsta);
  7310. {    regs.a[dstreg] += 2;
  7311. {    ULONG newv = dst + src;
  7312. {    bool flgs = ((WORD)(src)) < 0;
  7313.     bool flgo = ((WORD)(dst)) < 0;
  7314.     bool flgn = ((WORD)(newv)) < 0;
  7315.     regs.z = ((WORD)(newv)) == 0;
  7316.     regs.v = (flgs == flgo) && (flgn != flgo);
  7317.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7318.     regs.n = flgn != 0;
  7319.     put_word(dsta,newv);
  7320. }}}}}}}
  7321. void op_5e60(UWORD opcode)
  7322. {
  7323.     ULONG srcreg = 7;
  7324.     ULONG dstreg = (opcode & 7) >> 0;
  7325. {{    ULONG src = srcreg;
  7326. {    regs.a[dstreg] -= 2;
  7327. {    CPTR dsta = regs.a[dstreg];
  7328.     WORD dst = get_word(dsta);
  7329. {    ULONG newv = dst + src;
  7330. {    bool flgs = ((WORD)(src)) < 0;
  7331.     bool flgo = ((WORD)(dst)) < 0;
  7332.     bool flgn = ((WORD)(newv)) < 0;
  7333.     regs.z = ((WORD)(newv)) == 0;
  7334.     regs.v = (flgs == flgo) && (flgn != flgo);
  7335.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7336.     regs.n = flgn != 0;
  7337.     put_word(dsta,newv);
  7338. }}}}}}}
  7339. void op_5e68(UWORD opcode)
  7340. {
  7341.     ULONG srcreg = 7;
  7342.     ULONG dstreg = (opcode & 7) >> 0;
  7343. {{    ULONG src = srcreg;
  7344. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  7345.     WORD dst = get_word(dsta);
  7346. {    ULONG newv = dst + src;
  7347. {    bool flgs = ((WORD)(src)) < 0;
  7348.     bool flgo = ((WORD)(dst)) < 0;
  7349.     bool flgn = ((WORD)(newv)) < 0;
  7350.     regs.z = ((WORD)(newv)) == 0;
  7351.     regs.v = (flgs == flgo) && (flgn != flgo);
  7352.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7353.     regs.n = flgn != 0;
  7354.     put_word(dsta,newv);
  7355. }}}}}}
  7356. void op_5e70(UWORD opcode)
  7357. {
  7358.     ULONG srcreg = 7;
  7359.     ULONG dstreg = (opcode & 7) >> 0;
  7360. {{    ULONG src = srcreg;
  7361. {    CPTR dsta = regs.a[dstreg];
  7362.     UWORD dstdp = nextiword();
  7363.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7364. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7365.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7366.     dsta += dstdpr;
  7367. {    WORD dst = get_word(dsta);
  7368. {    ULONG newv = dst + src;
  7369. {    bool flgs = ((WORD)(src)) < 0;
  7370.     bool flgo = ((WORD)(dst)) < 0;
  7371.     bool flgn = ((WORD)(newv)) < 0;
  7372.     regs.z = ((WORD)(newv)) == 0;
  7373.     regs.v = (flgs == flgo) && (flgn != flgo);
  7374.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7375.     regs.n = flgn != 0;
  7376.     put_word(dsta,newv);
  7377. }}}}}}}}
  7378. void op_5e78(UWORD opcode)
  7379. {
  7380.     ULONG srcreg = 7;
  7381. {{    ULONG src = srcreg;
  7382. {    CPTR dsta = (LONG)(WORD)nextiword();
  7383.     WORD dst = get_word(dsta);
  7384. {    ULONG newv = dst + src;
  7385. {    bool flgs = ((WORD)(src)) < 0;
  7386.     bool flgo = ((WORD)(dst)) < 0;
  7387.     bool flgn = ((WORD)(newv)) < 0;
  7388.     regs.z = ((WORD)(newv)) == 0;
  7389.     regs.v = (flgs == flgo) && (flgn != flgo);
  7390.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7391.     regs.n = flgn != 0;
  7392.     put_word(dsta,newv);
  7393. }}}}}}
  7394. void op_5e79(UWORD opcode)
  7395. {
  7396.     ULONG srcreg = 7;
  7397. {{    ULONG src = srcreg;
  7398. {    CPTR dsta = nextilong();
  7399.     WORD dst = get_word(dsta);
  7400. {    ULONG newv = dst + src;
  7401. {    bool flgs = ((WORD)(src)) < 0;
  7402.     bool flgo = ((WORD)(dst)) < 0;
  7403.     bool flgn = ((WORD)(newv)) < 0;
  7404.     regs.z = ((WORD)(newv)) == 0;
  7405.     regs.v = (flgs == flgo) && (flgn != flgo);
  7406.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  7407.     regs.n = flgn != 0;
  7408.     put_word(dsta,newv);
  7409. }}}}}}
  7410. void op_5e80(UWORD opcode)
  7411. {
  7412.     ULONG srcreg = 7;
  7413.     ULONG dstreg = (opcode & 7) >> 0;
  7414. {{    ULONG src = srcreg;
  7415. {    LONG dst = regs.d[dstreg];
  7416. {    ULONG newv = dst + src;
  7417. {    bool flgs = ((LONG)(src)) < 0;
  7418.     bool flgo = ((LONG)(dst)) < 0;
  7419.     bool flgn = ((LONG)(newv)) < 0;
  7420.     regs.z = ((LONG)(newv)) == 0;
  7421.     regs.v = (flgs == flgo) && (flgn != flgo);
  7422.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7423.     regs.n = flgn != 0;
  7424.     regs.d[dstreg] = (newv);
  7425. }}}}}}
  7426. void op_5e88(UWORD opcode)
  7427. {
  7428.     ULONG srcreg = 7;
  7429.     ULONG dstreg = (opcode & 7) >> 0;
  7430. {{    ULONG src = srcreg;
  7431. {    LONG dst = regs.a[dstreg];
  7432. {    ULONG newv = dst + src;
  7433.     regs.a[dstreg] = (newv);
  7434. }}}}}
  7435. void op_5e90(UWORD opcode)
  7436. {
  7437.     ULONG srcreg = 7;
  7438.     ULONG dstreg = (opcode & 7) >> 0;
  7439. {{    ULONG src = srcreg;
  7440. {    CPTR dsta = regs.a[dstreg];
  7441.     LONG dst = get_long(dsta);
  7442. {    ULONG newv = dst + src;
  7443. {    bool flgs = ((LONG)(src)) < 0;
  7444.     bool flgo = ((LONG)(dst)) < 0;
  7445.     bool flgn = ((LONG)(newv)) < 0;
  7446.     regs.z = ((LONG)(newv)) == 0;
  7447.     regs.v = (flgs == flgo) && (flgn != flgo);
  7448.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7449.     regs.n = flgn != 0;
  7450.     put_long(dsta,newv);
  7451. }}}}}}
  7452. void op_5e98(UWORD opcode)
  7453. {
  7454.     ULONG srcreg = 7;
  7455.     ULONG dstreg = (opcode & 7) >> 0;
  7456. {{    ULONG src = srcreg;
  7457. {    CPTR dsta = regs.a[dstreg];
  7458.     LONG dst = get_long(dsta);
  7459. {    regs.a[dstreg] += 4;
  7460. {    ULONG newv = dst + src;
  7461. {    bool flgs = ((LONG)(src)) < 0;
  7462.     bool flgo = ((LONG)(dst)) < 0;
  7463.     bool flgn = ((LONG)(newv)) < 0;
  7464.     regs.z = ((LONG)(newv)) == 0;
  7465.     regs.v = (flgs == flgo) && (flgn != flgo);
  7466.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7467.     regs.n = flgn != 0;
  7468.     put_long(dsta,newv);
  7469. }}}}}}}
  7470. void op_5ea0(UWORD opcode)
  7471. {
  7472.     ULONG srcreg = 7;
  7473.     ULONG dstreg = (opcode & 7) >> 0;
  7474. {{    ULONG src = srcreg;
  7475. {    regs.a[dstreg] -= 4;
  7476. {    CPTR dsta = regs.a[dstreg];
  7477.     LONG dst = get_long(dsta);
  7478. {    ULONG newv = dst + src;
  7479. {    bool flgs = ((LONG)(src)) < 0;
  7480.     bool flgo = ((LONG)(dst)) < 0;
  7481.     bool flgn = ((LONG)(newv)) < 0;
  7482.     regs.z = ((LONG)(newv)) == 0;
  7483.     regs.v = (flgs == flgo) && (flgn != flgo);
  7484.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7485.     regs.n = flgn != 0;
  7486.     put_long(dsta,newv);
  7487. }}}}}}}
  7488. void op_5ea8(UWORD opcode)
  7489. {
  7490.     ULONG srcreg = 7;
  7491.     ULONG dstreg = (opcode & 7) >> 0;
  7492. {{    ULONG src = srcreg;
  7493. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  7494.     LONG dst = get_long(dsta);
  7495. {    ULONG newv = dst + src;
  7496. {    bool flgs = ((LONG)(src)) < 0;
  7497.     bool flgo = ((LONG)(dst)) < 0;
  7498.     bool flgn = ((LONG)(newv)) < 0;
  7499.     regs.z = ((LONG)(newv)) == 0;
  7500.     regs.v = (flgs == flgo) && (flgn != flgo);
  7501.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7502.     regs.n = flgn != 0;
  7503.     put_long(dsta,newv);
  7504. }}}}}}
  7505. void op_5eb0(UWORD opcode)
  7506. {
  7507.     ULONG srcreg = 7;
  7508.     ULONG dstreg = (opcode & 7) >> 0;
  7509. {{    ULONG src = srcreg;
  7510. {    CPTR dsta = regs.a[dstreg];
  7511.     UWORD dstdp = nextiword();
  7512.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7513. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7514.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7515.     dsta += dstdpr;
  7516. {    LONG dst = get_long(dsta);
  7517. {    ULONG newv = dst + src;
  7518. {    bool flgs = ((LONG)(src)) < 0;
  7519.     bool flgo = ((LONG)(dst)) < 0;
  7520.     bool flgn = ((LONG)(newv)) < 0;
  7521.     regs.z = ((LONG)(newv)) == 0;
  7522.     regs.v = (flgs == flgo) && (flgn != flgo);
  7523.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7524.     regs.n = flgn != 0;
  7525.     put_long(dsta,newv);
  7526. }}}}}}}}
  7527. void op_5eb8(UWORD opcode)
  7528. {
  7529.     ULONG srcreg = 7;
  7530. {{    ULONG src = srcreg;
  7531. {    CPTR dsta = (LONG)(WORD)nextiword();
  7532.     LONG dst = get_long(dsta);
  7533. {    ULONG newv = dst + src;
  7534. {    bool flgs = ((LONG)(src)) < 0;
  7535.     bool flgo = ((LONG)(dst)) < 0;
  7536.     bool flgn = ((LONG)(newv)) < 0;
  7537.     regs.z = ((LONG)(newv)) == 0;
  7538.     regs.v = (flgs == flgo) && (flgn != flgo);
  7539.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7540.     regs.n = flgn != 0;
  7541.     put_long(dsta,newv);
  7542. }}}}}}
  7543. void op_5eb9(UWORD opcode)
  7544. {
  7545.     ULONG srcreg = 7;
  7546. {{    ULONG src = srcreg;
  7547. {    CPTR dsta = nextilong();
  7548.     LONG dst = get_long(dsta);
  7549. {    ULONG newv = dst + src;
  7550. {    bool flgs = ((LONG)(src)) < 0;
  7551.     bool flgo = ((LONG)(dst)) < 0;
  7552.     bool flgn = ((LONG)(newv)) < 0;
  7553.     regs.z = ((LONG)(newv)) == 0;
  7554.     regs.v = (flgs == flgo) && (flgn != flgo);
  7555.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  7556.     regs.n = flgn != 0;
  7557.     put_long(dsta,newv);
  7558. }}}}}}
  7559. void op_5ec0(UWORD opcode)
  7560. {
  7561.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7562. {{{    int val = cctrue(14) ? 0xff : 0;
  7563.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  7564. }}}}
  7565. void op_5ec8(UWORD opcode)
  7566. {
  7567.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7568. {{    WORD src = regs.d[srcreg];
  7569. {    WORD offs = nextiword();
  7570.     if (!cctrue(14)) {
  7571.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  7572.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  7573.     }
  7574. }}}}
  7575. void op_5ed0(UWORD opcode)
  7576. {
  7577.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7578. {{    CPTR srca = regs.a[srcreg];
  7579. {    int val = cctrue(14) ? 0xff : 0;
  7580.     put_byte(srca,val);
  7581. }}}}
  7582. void op_5ed8(UWORD opcode)
  7583. {
  7584.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7585. {{    CPTR srca = regs.a[srcreg];
  7586. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  7587. {    int val = cctrue(14) ? 0xff : 0;
  7588.     put_byte(srca,val);
  7589. }}}}}
  7590. void op_5ee0(UWORD opcode)
  7591. {
  7592.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7593. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  7594. {    CPTR srca = regs.a[srcreg];
  7595. {    int val = cctrue(14) ? 0xff : 0;
  7596.     put_byte(srca,val);
  7597. }}}}}
  7598. void op_5ee8(UWORD opcode)
  7599. {
  7600.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7601. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  7602. {    int val = cctrue(14) ? 0xff : 0;
  7603.     put_byte(srca,val);
  7604. }}}}
  7605. void op_5ef0(UWORD opcode)
  7606. {
  7607.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  7608. {{    CPTR srca = regs.a[srcreg];
  7609.     UWORD srcdp = nextiword();
  7610.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  7611. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  7612.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  7613.     srca += srcdpr;
  7614. {    int val = cctrue(14) ? 0xff : 0;
  7615.     put_byte(srca,val);
  7616. }}}}}
  7617. void op_5ef8(UWORD opcode)
  7618. {
  7619. {{    CPTR srca = (LONG)(WORD)nextiword();
  7620. {    int val = cctrue(14) ? 0xff : 0;
  7621.     put_byte(srca,val);
  7622. }}}}
  7623. void op_5ef9(UWORD opcode)
  7624. {
  7625. {{    CPTR srca = nextilong();
  7626. {    int val = cctrue(14) ? 0xff : 0;
  7627.     put_byte(srca,val);
  7628. }}}}
  7629. void op_5f00(UWORD opcode)
  7630. {
  7631.     ULONG srcreg = 7;
  7632.     ULONG dstreg = (opcode & 7) >> 0;
  7633. {{    ULONG src = srcreg;
  7634. {    BYTE dst = regs.d[dstreg];
  7635. {    ULONG newv = dst - src;
  7636. {    bool flgs = ((BYTE)(src)) < 0;
  7637.     bool flgo = ((BYTE)(dst)) < 0;
  7638.     bool flgn = ((BYTE)(newv)) < 0;
  7639.     regs.z = ((BYTE)(newv)) == 0;
  7640.     regs.v = (flgs != flgo) && (flgn != flgo);
  7641.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7642.     regs.n = flgn != 0;
  7643.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  7644. }}}}}}
  7645. void op_5f10(UWORD opcode)
  7646. {
  7647.     ULONG srcreg = 7;
  7648.     ULONG dstreg = (opcode & 7) >> 0;
  7649. {{    ULONG src = srcreg;
  7650. {    CPTR dsta = regs.a[dstreg];
  7651.     BYTE dst = get_byte(dsta);
  7652. {    ULONG newv = dst - src;
  7653. {    bool flgs = ((BYTE)(src)) < 0;
  7654.     bool flgo = ((BYTE)(dst)) < 0;
  7655.     bool flgn = ((BYTE)(newv)) < 0;
  7656.     regs.z = ((BYTE)(newv)) == 0;
  7657.     regs.v = (flgs != flgo) && (flgn != flgo);
  7658.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7659.     regs.n = flgn != 0;
  7660.     put_byte(dsta,newv);
  7661. }}}}}}
  7662. void op_5f18(UWORD opcode)
  7663. {
  7664.     ULONG srcreg = 7;
  7665.     ULONG dstreg = (opcode & 7) >> 0;
  7666. {{    ULONG src = srcreg;
  7667. {    CPTR dsta = regs.a[dstreg];
  7668.     BYTE dst = get_byte(dsta);
  7669. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  7670. {    ULONG newv = dst - src;
  7671. {    bool flgs = ((BYTE)(src)) < 0;
  7672.     bool flgo = ((BYTE)(dst)) < 0;
  7673.     bool flgn = ((BYTE)(newv)) < 0;
  7674.     regs.z = ((BYTE)(newv)) == 0;
  7675.     regs.v = (flgs != flgo) && (flgn != flgo);
  7676.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7677.     regs.n = flgn != 0;
  7678.     put_byte(dsta,newv);
  7679. }}}}}}}
  7680. void op_5f20(UWORD opcode)
  7681. {
  7682.     ULONG srcreg = 7;
  7683.     ULONG dstreg = (opcode & 7) >> 0;
  7684. {{    ULONG src = srcreg;
  7685. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  7686. {    CPTR dsta = regs.a[dstreg];
  7687.     BYTE dst = get_byte(dsta);
  7688. {    ULONG newv = dst - src;
  7689. {    bool flgs = ((BYTE)(src)) < 0;
  7690.     bool flgo = ((BYTE)(dst)) < 0;
  7691.     bool flgn = ((BYTE)(newv)) < 0;
  7692.     regs.z = ((BYTE)(newv)) == 0;
  7693.     regs.v = (flgs != flgo) && (flgn != flgo);
  7694.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7695.     regs.n = flgn != 0;
  7696.     put_byte(dsta,newv);
  7697. }}}}}}}
  7698. void op_5f28(UWORD opcode)
  7699. {
  7700.     ULONG srcreg = 7;
  7701.     ULONG dstreg = (opcode & 7) >> 0;
  7702. {{    ULONG src = srcreg;
  7703. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  7704.     BYTE dst = get_byte(dsta);
  7705. {    ULONG newv = dst - src;
  7706. {    bool flgs = ((BYTE)(src)) < 0;
  7707.     bool flgo = ((BYTE)(dst)) < 0;
  7708.     bool flgn = ((BYTE)(newv)) < 0;
  7709.     regs.z = ((BYTE)(newv)) == 0;
  7710.     regs.v = (flgs != flgo) && (flgn != flgo);
  7711.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7712.     regs.n = flgn != 0;
  7713.     put_byte(dsta,newv);
  7714. }}}}}}
  7715. void op_5f30(UWORD opcode)
  7716. {
  7717.     ULONG srcreg = 7;
  7718.     ULONG dstreg = (opcode & 7) >> 0;
  7719. {{    ULONG src = srcreg;
  7720. {    CPTR dsta = regs.a[dstreg];
  7721.     UWORD dstdp = nextiword();
  7722.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7723. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7724.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7725.     dsta += dstdpr;
  7726. {    BYTE dst = get_byte(dsta);
  7727. {    ULONG newv = dst - src;
  7728. {    bool flgs = ((BYTE)(src)) < 0;
  7729.     bool flgo = ((BYTE)(dst)) < 0;
  7730.     bool flgn = ((BYTE)(newv)) < 0;
  7731.     regs.z = ((BYTE)(newv)) == 0;
  7732.     regs.v = (flgs != flgo) && (flgn != flgo);
  7733.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7734.     regs.n = flgn != 0;
  7735.     put_byte(dsta,newv);
  7736. }}}}}}}}
  7737. void op_5f38(UWORD opcode)
  7738. {
  7739.     ULONG srcreg = 7;
  7740. {{    ULONG src = srcreg;
  7741. {    CPTR dsta = (LONG)(WORD)nextiword();
  7742.     BYTE dst = get_byte(dsta);
  7743. {    ULONG newv = dst - src;
  7744. {    bool flgs = ((BYTE)(src)) < 0;
  7745.     bool flgo = ((BYTE)(dst)) < 0;
  7746.     bool flgn = ((BYTE)(newv)) < 0;
  7747.     regs.z = ((BYTE)(newv)) == 0;
  7748.     regs.v = (flgs != flgo) && (flgn != flgo);
  7749.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7750.     regs.n = flgn != 0;
  7751.     put_byte(dsta,newv);
  7752. }}}}}}
  7753. void op_5f39(UWORD opcode)
  7754. {
  7755.     ULONG srcreg = 7;
  7756. {{    ULONG src = srcreg;
  7757. {    CPTR dsta = nextilong();
  7758.     BYTE dst = get_byte(dsta);
  7759. {    ULONG newv = dst - src;
  7760. {    bool flgs = ((BYTE)(src)) < 0;
  7761.     bool flgo = ((BYTE)(dst)) < 0;
  7762.     bool flgn = ((BYTE)(newv)) < 0;
  7763.     regs.z = ((BYTE)(newv)) == 0;
  7764.     regs.v = (flgs != flgo) && (flgn != flgo);
  7765.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  7766.     regs.n = flgn != 0;
  7767.     put_byte(dsta,newv);
  7768. }}}}}}
  7769. void op_5f40(UWORD opcode)
  7770. {
  7771.     ULONG srcreg = 7;
  7772.     ULONG dstreg = (opcode & 7) >> 0;
  7773. {{    ULONG src = srcreg;
  7774. {    WORD dst = regs.d[dstreg];
  7775. {    ULONG newv = dst - src;
  7776. {    bool flgs = ((WORD)(src)) < 0;
  7777.     bool flgo = ((WORD)(dst)) < 0;
  7778.     bool flgn = ((WORD)(newv)) < 0;
  7779.     regs.z = ((WORD)(newv)) == 0;
  7780.     regs.v = (flgs != flgo) && (flgn != flgo);
  7781.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7782.     regs.n = flgn != 0;
  7783.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  7784. }}}}}}
  7785. void op_5f48(UWORD opcode)
  7786. {
  7787.     ULONG srcreg = 7;
  7788.     ULONG dstreg = (opcode & 7) >> 0;
  7789. {{    ULONG src = srcreg;
  7790. {    LONG dst = regs.a[dstreg];
  7791. {    ULONG newv = dst - src;
  7792.     regs.a[dstreg] = (newv);
  7793. }}}}}
  7794. void op_5f50(UWORD opcode)
  7795. {
  7796.     ULONG srcreg = 7;
  7797.     ULONG dstreg = (opcode & 7) >> 0;
  7798. {{    ULONG src = srcreg;
  7799. {    CPTR dsta = regs.a[dstreg];
  7800.     WORD dst = get_word(dsta);
  7801. {    ULONG newv = dst - src;
  7802. {    bool flgs = ((WORD)(src)) < 0;
  7803.     bool flgo = ((WORD)(dst)) < 0;
  7804.     bool flgn = ((WORD)(newv)) < 0;
  7805.     regs.z = ((WORD)(newv)) == 0;
  7806.     regs.v = (flgs != flgo) && (flgn != flgo);
  7807.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7808.     regs.n = flgn != 0;
  7809.     put_word(dsta,newv);
  7810. }}}}}}
  7811. void op_5f58(UWORD opcode)
  7812. {
  7813.     ULONG srcreg = 7;
  7814.     ULONG dstreg = (opcode & 7) >> 0;
  7815. {{    ULONG src = srcreg;
  7816. {    CPTR dsta = regs.a[dstreg];
  7817.     WORD dst = get_word(dsta);
  7818. {    regs.a[dstreg] += 2;
  7819. {    ULONG newv = dst - src;
  7820. {    bool flgs = ((WORD)(src)) < 0;
  7821.     bool flgo = ((WORD)(dst)) < 0;
  7822.     bool flgn = ((WORD)(newv)) < 0;
  7823.     regs.z = ((WORD)(newv)) == 0;
  7824.     regs.v = (flgs != flgo) && (flgn != flgo);
  7825.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7826.     regs.n = flgn != 0;
  7827.     put_word(dsta,newv);
  7828. }}}}}}}
  7829. void op_5f60(UWORD opcode)
  7830. {
  7831.     ULONG srcreg = 7;
  7832.     ULONG dstreg = (opcode & 7) >> 0;
  7833. {{    ULONG src = srcreg;
  7834. {    regs.a[dstreg] -= 2;
  7835. {    CPTR dsta = regs.a[dstreg];
  7836.     WORD dst = get_word(dsta);
  7837. {    ULONG newv = dst - src;
  7838. {    bool flgs = ((WORD)(src)) < 0;
  7839.     bool flgo = ((WORD)(dst)) < 0;
  7840.     bool flgn = ((WORD)(newv)) < 0;
  7841.     regs.z = ((WORD)(newv)) == 0;
  7842.     regs.v = (flgs != flgo) && (flgn != flgo);
  7843.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7844.     regs.n = flgn != 0;
  7845.     put_word(dsta,newv);
  7846. }}}}}}}
  7847. void op_5f68(UWORD opcode)
  7848. {
  7849.     ULONG srcreg = 7;
  7850.     ULONG dstreg = (opcode & 7) >> 0;
  7851. {{    ULONG src = srcreg;
  7852. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  7853.     WORD dst = get_word(dsta);
  7854. {    ULONG newv = dst - src;
  7855. {    bool flgs = ((WORD)(src)) < 0;
  7856.     bool flgo = ((WORD)(dst)) < 0;
  7857.     bool flgn = ((WORD)(newv)) < 0;
  7858.     regs.z = ((WORD)(newv)) == 0;
  7859.     regs.v = (flgs != flgo) && (flgn != flgo);
  7860.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7861.     regs.n = flgn != 0;
  7862.     put_word(dsta,newv);
  7863. }}}}}}
  7864. void op_5f70(UWORD opcode)
  7865. {
  7866.     ULONG srcreg = 7;
  7867.     ULONG dstreg = (opcode & 7) >> 0;
  7868. {{    ULONG src = srcreg;
  7869. {    CPTR dsta = regs.a[dstreg];
  7870.     UWORD dstdp = nextiword();
  7871.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  7872. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  7873.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  7874.     dsta += dstdpr;
  7875. {    WORD dst = get_word(dsta);
  7876. {    ULONG newv = dst - src;
  7877. {    bool flgs = ((WORD)(src)) < 0;
  7878.     bool flgo = ((WORD)(dst)) < 0;
  7879.     bool flgn = ((WORD)(newv)) < 0;
  7880.     regs.z = ((WORD)(newv)) == 0;
  7881.     regs.v = (flgs != flgo) && (flgn != flgo);
  7882.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7883.     regs.n = flgn != 0;
  7884.     put_word(dsta,newv);
  7885. }}}}}}}}
  7886. void op_5f78(UWORD opcode)
  7887. {
  7888.     ULONG srcreg = 7;
  7889. {{    ULONG src = srcreg;
  7890. {    CPTR dsta = (LONG)(WORD)nextiword();
  7891.     WORD dst = get_word(dsta);
  7892. {    ULONG newv = dst - src;
  7893. {    bool flgs = ((WORD)(src)) < 0;
  7894.     bool flgo = ((WORD)(dst)) < 0;
  7895.     bool flgn = ((WORD)(newv)) < 0;
  7896.     regs.z = ((WORD)(newv)) == 0;
  7897.     regs.v = (flgs != flgo) && (flgn != flgo);
  7898.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7899.     regs.n = flgn != 0;
  7900.     put_word(dsta,newv);
  7901. }}}}}}
  7902. void op_5f79(UWORD opcode)
  7903. {
  7904.     ULONG srcreg = 7;
  7905. {{    ULONG src = srcreg;
  7906. {    CPTR dsta = nextilong();
  7907.     WORD dst = get_word(dsta);
  7908. {    ULONG newv = dst - src;
  7909. {    bool flgs = ((WORD)(src)) < 0;
  7910.     bool flgo = ((WORD)(dst)) < 0;
  7911.     bool flgn = ((WORD)(newv)) < 0;
  7912.     regs.z = ((WORD)(newv)) == 0;
  7913.     regs.v = (flgs != flgo) && (flgn != flgo);
  7914.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  7915.     regs.n = flgn != 0;
  7916.     put_word(dsta,newv);
  7917. }}}}}}
  7918. void op_5f80(UWORD opcode)
  7919. {
  7920.     ULONG srcreg = 7;
  7921.     ULONG dstreg = (opcode & 7) >> 0;
  7922. {{    ULONG src = srcreg;
  7923. {    LONG dst = regs.d[dstreg];
  7924. {    ULONG newv = dst - src;
  7925. {    bool flgs = ((LONG)(src)) < 0;
  7926.     bool flgo = ((LONG)(dst)) < 0;
  7927.     bool flgn = ((LONG)(newv)) < 0;
  7928.     regs.z = ((LONG)(newv)) == 0;
  7929.     regs.v = (flgs != flgo) && (flgn != flgo);
  7930.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7931.     regs.n = flgn != 0;
  7932.     regs.d[dstreg] = (newv);
  7933. }}}}}}
  7934. void op_5f88(UWORD opcode)
  7935. {
  7936.     ULONG srcreg = 7;
  7937.     ULONG dstreg = (opcode & 7) >> 0;
  7938. {{    ULONG src = srcreg;
  7939. {    LONG dst = regs.a[dstreg];
  7940. {    ULONG newv = dst - src;
  7941.     regs.a[dstreg] = (newv);
  7942. }}}}}
  7943. void op_5f90(UWORD opcode)
  7944. {
  7945.     ULONG srcreg = 7;
  7946.     ULONG dstreg = (opcode & 7) >> 0;
  7947. {{    ULONG src = srcreg;
  7948. {    CPTR dsta = regs.a[dstreg];
  7949.     LONG dst = get_long(dsta);
  7950. {    ULONG newv = dst - src;
  7951. {    bool flgs = ((LONG)(src)) < 0;
  7952.     bool flgo = ((LONG)(dst)) < 0;
  7953.     bool flgn = ((LONG)(newv)) < 0;
  7954.     regs.z = ((LONG)(newv)) == 0;
  7955.     regs.v = (flgs != flgo) && (flgn != flgo);
  7956.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7957.     regs.n = flgn != 0;
  7958.     put_long(dsta,newv);
  7959. }}}}}}
  7960. void op_5f98(UWORD opcode)
  7961. {
  7962.     ULONG srcreg = 7;
  7963.     ULONG dstreg = (opcode & 7) >> 0;
  7964. {{    ULONG src = srcreg;
  7965. {    CPTR dsta = regs.a[dstreg];
  7966.     LONG dst = get_long(dsta);
  7967. {    regs.a[dstreg] += 4;
  7968. {    ULONG newv = dst - src;
  7969. {    bool flgs = ((LONG)(src)) < 0;
  7970.     bool flgo = ((LONG)(dst)) < 0;
  7971.     bool flgn = ((LONG)(newv)) < 0;
  7972.     regs.z = ((LONG)(newv)) == 0;
  7973.     regs.v = (flgs != flgo) && (flgn != flgo);
  7974.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7975.     regs.n = flgn != 0;
  7976.     put_long(dsta,newv);
  7977. }}}}}}}
  7978. void op_5fa0(UWORD opcode)
  7979. {
  7980.     ULONG srcreg = 7;
  7981.     ULONG dstreg = (opcode & 7) >> 0;
  7982. {{    ULONG src = srcreg;
  7983. {    regs.a[dstreg] -= 4;
  7984. {    CPTR dsta = regs.a[dstreg];
  7985.     LONG dst = get_long(dsta);
  7986. {    ULONG newv = dst - src;
  7987. {    bool flgs = ((LONG)(src)) < 0;
  7988.     bool flgo = ((LONG)(dst)) < 0;
  7989.     bool flgn = ((LONG)(newv)) < 0;
  7990.     regs.z = ((LONG)(newv)) == 0;
  7991.     regs.v = (flgs != flgo) && (flgn != flgo);
  7992.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  7993.     regs.n = flgn != 0;
  7994.     put_long(dsta,newv);
  7995. }}}}}}}
  7996. void op_5fa8(UWORD opcode)
  7997. {
  7998.     ULONG srcreg = 7;
  7999.     ULONG dstreg = (opcode & 7) >> 0;
  8000. {{    ULONG src = srcreg;
  8001. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  8002.     LONG dst = get_long(dsta);
  8003. {    ULONG newv = dst - src;
  8004. {    bool flgs = ((LONG)(src)) < 0;
  8005.     bool flgo = ((LONG)(dst)) < 0;
  8006.     bool flgn = ((LONG)(newv)) < 0;
  8007.     regs.z = ((LONG)(newv)) == 0;
  8008.     regs.v = (flgs != flgo) && (flgn != flgo);
  8009.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  8010.     regs.n = flgn != 0;
  8011.     put_long(dsta,newv);
  8012. }}}}}}
  8013. void op_5fb0(UWORD opcode)
  8014. {
  8015.     ULONG srcreg = 7;
  8016.     ULONG dstreg = (opcode & 7) >> 0;
  8017. {{    ULONG src = srcreg;
  8018. {    CPTR dsta = regs.a[dstreg];
  8019.     UWORD dstdp = nextiword();
  8020.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  8021. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  8022.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  8023.     dsta += dstdpr;
  8024. {    LONG dst = get_long(dsta);
  8025. {    ULONG newv = dst - src;
  8026. {    bool flgs = ((LONG)(src)) < 0;
  8027.     bool flgo = ((LONG)(dst)) < 0;
  8028.     bool flgn = ((LONG)(newv)) < 0;
  8029.     regs.z = ((LONG)(newv)) == 0;
  8030.     regs.v = (flgs != flgo) && (flgn != flgo);
  8031.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  8032.     regs.n = flgn != 0;
  8033.     put_long(dsta,newv);
  8034. }}}}}}}}
  8035. void op_5fb8(UWORD opcode)
  8036. {
  8037.     ULONG srcreg = 7;
  8038. {{    ULONG src = srcreg;
  8039. {    CPTR dsta = (LONG)(WORD)nextiword();
  8040.     LONG dst = get_long(dsta);
  8041. {    ULONG newv = dst - src;
  8042. {    bool flgs = ((LONG)(src)) < 0;
  8043.     bool flgo = ((LONG)(dst)) < 0;
  8044.     bool flgn = ((LONG)(newv)) < 0;
  8045.     regs.z = ((LONG)(newv)) == 0;
  8046.     regs.v = (flgs != flgo) && (flgn != flgo);
  8047.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  8048.     regs.n = flgn != 0;
  8049.     put_long(dsta,newv);
  8050. }}}}}}
  8051. void op_5fb9(UWORD opcode)
  8052. {
  8053.     ULONG srcreg = 7;
  8054. {{    ULONG src = srcreg;
  8055. {    CPTR dsta = nextilong();
  8056.     LONG dst = get_long(dsta);
  8057. {    ULONG newv = dst - src;
  8058. {    bool flgs = ((LONG)(src)) < 0;
  8059.     bool flgo = ((LONG)(dst)) < 0;
  8060.     bool flgn = ((LONG)(newv)) < 0;
  8061.     regs.z = ((LONG)(newv)) == 0;
  8062.     regs.v = (flgs != flgo) && (flgn != flgo);
  8063.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  8064.     regs.n = flgn != 0;
  8065.     put_long(dsta,newv);
  8066. }}}}}}
  8067. void op_5fc0(UWORD opcode)
  8068. {
  8069.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8070. {{{    int val = cctrue(15) ? 0xff : 0;
  8071.     regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
  8072. }}}}
  8073. void op_5fc8(UWORD opcode)
  8074. {
  8075.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8076. {{    WORD src = regs.d[srcreg];
  8077. {    WORD offs = nextiword();
  8078.     if (!cctrue(15)) {
  8079.     if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
  8080.     regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
  8081.     }
  8082. }}}}
  8083. void op_5fd0(UWORD opcode)
  8084. {
  8085.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8086. {{    CPTR srca = regs.a[srcreg];
  8087. {    int val = cctrue(15) ? 0xff : 0;
  8088.     put_byte(srca,val);
  8089. }}}}
  8090. void op_5fd8(UWORD opcode)
  8091. {
  8092.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8093. {{    CPTR srca = regs.a[srcreg];
  8094. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  8095. {    int val = cctrue(15) ? 0xff : 0;
  8096.     put_byte(srca,val);
  8097. }}}}}
  8098. void op_5fe0(UWORD opcode)
  8099. {
  8100.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8101. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  8102. {    CPTR srca = regs.a[srcreg];
  8103. {    int val = cctrue(15) ? 0xff : 0;
  8104.     put_byte(srca,val);
  8105. }}}}}
  8106. void op_5fe8(UWORD opcode)
  8107. {
  8108.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8109. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  8110. {    int val = cctrue(15) ? 0xff : 0;
  8111.     put_byte(srca,val);
  8112. }}}}
  8113. void op_5ff0(UWORD opcode)
  8114. {
  8115.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  8116. {{    CPTR srca = regs.a[srcreg];
  8117.     UWORD srcdp = nextiword();
  8118.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  8119. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  8120.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  8121.     srca += srcdpr;
  8122. {    int val = cctrue(15) ? 0xff : 0;
  8123.     put_byte(srca,val);
  8124. }}}}}
  8125. void op_5ff8(UWORD opcode)
  8126. {
  8127. {{    CPTR srca = (LONG)(WORD)nextiword();
  8128. {    int val = cctrue(15) ? 0xff : 0;
  8129.     put_byte(srca,val);
  8130. }}}}
  8131. void op_5ff9(UWORD opcode)
  8132. {
  8133. {{    CPTR srca = nextilong();
  8134. {    int val = cctrue(15) ? 0xff : 0;
  8135.     put_byte(srca,val);
  8136. }}}}
  8137.